Add mux-stream transport support in session description

remoting/protocol/jingle_messages.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/jingle_messages.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/content_description.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 kJabberNamespace[] = "jabber:client";
 const char kJingleNamespace[] = "urn:xmpp:jingle:1";
 const char kP2PTransportNamespace[] = "http://www.google.com/transport/p2p";
 
 namespace {
 
 const char kEmptyNamespace[] = "";
 const char kXmlNamespace[] = "http://www.w3.org/XML/1998/namespace";
 
 const int kPortMin = 1000;
 const int kPortMax = 65535;
 
-template <typename T>
-struct NameMapElement {
-  const T value;
-  const char* const name;
-};
-
-template <typename T>
-const char* ValueToName(const NameMapElement<T> map[], size_t map_size,
-                              T value) {
-  for (size_t i = 0; i < map_size; ++i) {
-    if (map[i].value == value)
-      return map[i].name;
-  }
-  return NULL;
-}
-
-template <typename T>
-T NameToValue(const NameMapElement<T> map[], size_t map_size,
-                    const std::string& name, T default_value) {
-  for (size_t i = 0; i < map_size; ++i) {
-    if (map[i].name == name)
-      return map[i].value;
-  }
-  return default_value;
-}
-
 const NameMapElement<JingleMessage::ActionType> kActionTypes[] = {
   { JingleMessage::SESSION_INITIATE, "session-initiate" },
   { JingleMessage::SESSION_ACCEPT, "session-accept" },
   { JingleMessage::SESSION_TERMINATE, "session-terminate" },
   { JingleMessage::SESSION_INFO, "session-info" },
   { JingleMessage::TRANSPORT_INFO, "transport-info" },
 };
 
 const NameMapElement<JingleMessage::Reason> kReasons[] = {
   { JingleMessage::SUCCESS, "success" },
@@ skipping 83 matching lines @@
 // static
 bool JingleMessage::IsJingleMessage(const buzz::XmlElement* stanza) {
   return
       stanza->Name() == QName(kJabberNamespace, "iq") &&
       stanza->Attr(QName("", "type")) == "set" &&
       stanza->FirstNamed(QName(kJingleNamespace, "jingle")) != NULL;
 }
 
 // static
 std::string JingleMessage::GetActionName(ActionType action) {
-  return ValueToName(kActionTypes, arraysize(kActionTypes), action);
+  return ValueToName(kActionTypes, action);
 }
 
 JingleMessage::JingleMessage()
     : action(UNKNOWN_ACTION),
       reason(UNKNOWN_REASON) {
 }
 
 JingleMessage::JingleMessage(
     const std::string& to_value,
     ActionType action_value,
     const std::string& sid_value)
     : to(to_value),
       action(action_value),
       sid(sid_value),
       reason(UNKNOWN_REASON) {
 }
 
 JingleMessage::~JingleMessage() {
 }
 
 bool JingleMessage::ParseXml(const buzz::XmlElement* stanza,
                              std::string* error) {
   if (!IsJingleMessage(stanza)) {
     *error = "Not a jingle message";
     return false;
   }
 
   const XmlElement* jingle_tag =
       stanza->FirstNamed(QName(kJingleNamespace, "jingle"));
-  if (jingle_tag == NULL) {
+  if (!jingle_tag) {
     *error = "Not a jingle message";
     return false;
   }
 
   from = stanza->Attr(QName(kEmptyNamespace, "from"));
   to = stanza->Attr(QName(kEmptyNamespace, "to"));
 
   std::string action_str = jingle_tag->Attr(QName(kEmptyNamespace, "action"));
   if (action_str.empty()) {
     *error = "action attribute is missing";
     return false;
   }
-  action = NameToValue(
-      kActionTypes, arraysize(kActionTypes), action_str, UNKNOWN_ACTION);
-  if (action == UNKNOWN_ACTION) {
+  if (!NameToValue(kActionTypes, action_str, &action)) {
     *error = "Unknown action " + action_str;
     return false;
   }
 
   sid = jingle_tag->Attr(QName(kEmptyNamespace, "sid"));
   if (sid.empty()) {
     *error = "sid attribute is missing";
     return false;
   }
 
   if (action == SESSION_INFO) {
     // session-info messages may contain arbitrary information not
     // defined by the Jingle protocol. We don't need to parse it.
     const XmlElement* child = jingle_tag->FirstElement();
     if (child) {
       // session-info is allowed to be empty.
       info.reset(new XmlElement(*child));
     } else {
       info.reset(NULL);
     }
     return true;
   }
 
   const XmlElement* reason_tag =
       jingle_tag->FirstNamed(QName(kJingleNamespace, "reason"));
   if (reason_tag && reason_tag->FirstElement()) {
-    reason = NameToValue(
-        kReasons, arraysize(kReasons),
-        reason_tag->FirstElement()->Name().LocalPart(), UNKNOWN_REASON);
+    if (!NameToValue(kReasons, reason_tag->FirstElement()->Name().LocalPart(),
+                     &reason)) {
+      reason = UNKNOWN_REASON;
+    }
   }
 
   if (action == SESSION_TERMINATE)
     return true;
 
   const XmlElement* content_tag =
       jingle_tag->FirstNamed(QName(kJingleNamespace, "content"));
   if (!content_tag) {
     *error = "content tag is missing";
     return false;
@@ skipping 50 matching lines @@
   root->AddAttr(QName(kEmptyNamespace, "to"), to);
   if (!from.empty())
     root->AddAttr(QName(kEmptyNamespace, "from"), from);
   root->SetAttr(QName(kEmptyNamespace, "type"), "set");
 
   XmlElement* jingle_tag =
       new XmlElement(QName(kJingleNamespace, "jingle"), true);
   root->AddElement(jingle_tag);
   jingle_tag->AddAttr(QName(kEmptyNamespace, "sid"), sid);
 
-  const char* action_attr = ValueToName(
-      kActionTypes, arraysize(kActionTypes), action);
+  const char* action_attr = ValueToName(kActionTypes, action);
   if (!action_attr)
     LOG(FATAL) << "Invalid action value " << action;
   jingle_tag->AddAttr(QName(kEmptyNamespace, "action"), action_attr);
 
   if (action == SESSION_INFO) {
     if (info.get())
       jingle_tag->AddElement(new XmlElement(*info.get()));
     return root.Pass();
   }
 
   if (action == SESSION_INITIATE)
     jingle_tag->AddAttr(QName(kEmptyNamespace, "initiator"), from);
 
   if (reason != UNKNOWN_REASON) {
     XmlElement* reason_tag = new XmlElement(QName(kJingleNamespace, "reason"));
     jingle_tag->AddElement(reason_tag);
     const char* reason_string =
-        ValueToName(kReasons, arraysize(kReasons), reason);
-    if (reason_string == NULL)
+        ValueToName(kReasons, reason);
+    if (!reason_string)
       LOG(FATAL) << "Invalid reason: " << reason;
     reason_tag->AddElement(new XmlElement(
         QName(kJingleNamespace, reason_string)));
   }
 
   if (action != SESSION_TERMINATE) {
     XmlElement* content_tag =
         new XmlElement(QName(kJingleNamespace, "content"));
     jingle_tag->AddElement(content_tag);
 
@@ skipping 112 matching lines @@
     text_elem->SetAttr(QName(kXmlNamespace, "lang"), "en");
     text_elem->SetBodyText(error_text);
     error->AddElement(text_elem);
   }
 
   return iq.Pass();
 }
 
 }  // namespace protocol
 }  // namespace remoting