Add TransportSession interface to prepare for WebRTC-based transport.

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/strings/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/content_description.h"
@@ skipping 30 matching lines @@
 
 const NameMapElement<JingleMessage::Reason> kReasons[] = {
   { JingleMessage::SUCCESS, "success" },
   { JingleMessage::DECLINE, "decline" },
   { JingleMessage::CANCEL, "cancel" },
   { JingleMessage::GENERAL_ERROR, "general-error" },
   { JingleMessage::INCOMPATIBLE_PARAMETERS, "incompatible-parameters" },
 };
 
 bool ParseIceCredentials(const buzz::XmlElement* element,
-                         JingleMessage::IceCredentials* credentials) {
+                         IceTransportInfo::IceCredentials* credentials) {
   DCHECK(element->Name() == QName(kIceTransportNamespace, "credentials"));
 
   const std::string& channel = element->Attr(QName(kEmptyNamespace, "channel"));
   const std::string& ufrag =
       element->Attr(QName(kEmptyNamespace, "ufrag"));
   const std::string& password =
       element->Attr(QName(kEmptyNamespace, "password"));
 
   if (channel.empty() || ufrag.empty() || password.empty()) {
     return false;
   }
 
   credentials->channel = channel;
   credentials->ufrag = ufrag;
   credentials->password = password;
 
   return true;
 }
 
 bool ParseIceCandidate(const buzz::XmlElement* element,
-                       JingleMessage::NamedCandidate* candidate) {
+                       IceTransportInfo::NamedCandidate* candidate) {
   DCHECK(element->Name() == QName(kIceTransportNamespace, "candidate"));
 
   const std::string& name = element->Attr(QName(kEmptyNamespace, "name"));
   const std::string& foundation =
       element->Attr(QName(kEmptyNamespace, "foundation"));
   const std::string& address = element->Attr(QName(kEmptyNamespace, "address"));
   const std::string& port_str = element->Attr(QName(kEmptyNamespace, "port"));
   const std::string& type = element->Attr(QName(kEmptyNamespace, "type"));
   const std::string& protocol =
       element->Attr(QName(kEmptyNamespace, "protocol"));
@@ skipping 18 matching lines @@
   candidate->candidate.set_foundation(foundation);
   candidate->candidate.set_address(rtc::SocketAddress(address, port));
   candidate->candidate.set_type(type);
   candidate->candidate.set_protocol(protocol);
   candidate->candidate.set_priority(priority);
   candidate->candidate.set_generation(generation);
 
   return true;
 }
 
-bool ParseIceTransportInfo(
-    const buzz::XmlElement* element,
-    std::list<JingleMessage::IceCredentials>* ice_credentials,
-    std::list<JingleMessage::NamedCandidate>* candidates) {
-  DCHECK(element->Name() == QName(kIceTransportNamespace, "transport"));
-
-  ice_credentials->clear();
-  candidates->clear();
-
-  QName qn_credentials(kIceTransportNamespace, "credentials");
-  for (const XmlElement* credentials_tag = element->FirstNamed(qn_credentials);
-       credentials_tag;
-       credentials_tag = credentials_tag->NextNamed(qn_credentials)) {
-    JingleMessage::IceCredentials credentials;
-    if (!ParseIceCredentials(credentials_tag, &credentials))
-      return false;
-    ice_credentials->push_back(credentials);
-  }
-
-  QName qn_candidate(kIceTransportNamespace, "candidate");
-  for (const XmlElement* candidate_tag = element->FirstNamed(qn_candidate);
-       candidate_tag; candidate_tag = candidate_tag->NextNamed(qn_candidate)) {
-    JingleMessage::NamedCandidate candidate;
-    if (!ParseIceCandidate(candidate_tag, &candidate))
-      return false;
-    candidates->push_back(candidate);
-  }
-
-  return true;
-}
-
 XmlElement* FormatIceCredentials(
-    const JingleMessage::IceCredentials& credentials) {
+    const IceTransportInfo::IceCredentials& credentials) {
   XmlElement* result =
       new XmlElement(QName(kIceTransportNamespace, "credentials"));
   result->SetAttr(QName(kEmptyNamespace, "channel"), credentials.channel);
   result->SetAttr(QName(kEmptyNamespace, "ufrag"), credentials.ufrag);
   result->SetAttr(QName(kEmptyNamespace, "password"), credentials.password);
   return result;
 }
 
-XmlElement* FormatIceCandidate(const JingleMessage::NamedCandidate& candidate) {
+XmlElement* FormatIceCandidate(
+    const IceTransportInfo::NamedCandidate& candidate) {
   XmlElement* result =
       new XmlElement(QName(kIceTransportNamespace, "candidate"));
   result->SetAttr(QName(kEmptyNamespace, "name"), candidate.name);
   result->SetAttr(QName(kEmptyNamespace, "foundation"),
                   candidate.candidate.foundation());
   result->SetAttr(QName(kEmptyNamespace, "address"),
                   candidate.candidate.address().ipaddr().ToString());
   result->SetAttr(QName(kEmptyNamespace, "port"),
                   base::UintToString(candidate.candidate.address().port()));
   result->SetAttr(QName(kEmptyNamespace, "type"), candidate.candidate.type());
   result->SetAttr(QName(kEmptyNamespace, "protocol"),
                   candidate.candidate.protocol());
   result->SetAttr(QName(kEmptyNamespace, "priority"),
                   base::UintToString(candidate.candidate.priority()));
   result->SetAttr(QName(kEmptyNamespace, "generation"),
                   base::UintToString(candidate.candidate.generation()));
   return result;
 }
 
 }  // namespace
 
-JingleMessage::NamedCandidate::NamedCandidate(
+IceTransportInfo::NamedCandidate::NamedCandidate(
     const std::string& name,
     const cricket::Candidate& candidate)
     : name(name),
       candidate(candidate) {
 }
 
-JingleMessage::IceCredentials::IceCredentials(std::string channel,
+IceTransportInfo::IceCredentials::IceCredentials(std::string channel,
                                               std::string ufrag,
                                               std::string password)
     : channel(channel), ufrag(ufrag), password(password) {
 }
 
 // static
 bool JingleMessage::IsJingleMessage(const buzz::XmlElement* stanza) {
   return stanza->Name() == QName(kJabberNamespace, "iq") &&
          stanza->Attr(QName(std::string(), "type")) == "set" &&
          stanza->FirstNamed(QName(kJingleNamespace, "jingle")) != nullptr;
@@ skipping 97 matching lines @@
     description = ContentDescription::ParseXml(description_tag);
     if (!description.get()) {
       *error = "Failed to parse content description";
       return false;
     }
   }
 
   const XmlElement* ice_transport_tag = content_tag->FirstNamed(
       QName(kIceTransportNamespace, "transport"));
   if (ice_transport_tag) {
-    if (!ParseIceTransportInfo(ice_transport_tag, &ice_credentials,
-                               &candidates)) {
-      *error = "Failed to parse transport info";
-      return false;
-    }
+    transport_info.reset(new buzz::XmlElement(*ice_transport_tag));
   }
 
   return true;
 }
 
 scoped_ptr<buzz::XmlElement> JingleMessage::ToXml() const {
   scoped_ptr<XmlElement> root(
       new XmlElement(QName("jabber:client", "iq"), true));
 
   DCHECK(!to.empty());
@@ skipping 37 matching lines @@
         new XmlElement(QName(kJingleNamespace, "content"));
     jingle_tag->AddElement(content_tag);
 
     content_tag->AddAttr(QName(kEmptyNamespace, "name"),
                          ContentDescription::kChromotingContentName);
     content_tag->AddAttr(QName(kEmptyNamespace, "creator"), "initiator");
 
     if (description.get())
       content_tag->AddElement(description->ToXml());
 
-    if (!ice_credentials.empty() || !candidates.empty()) {
-      XmlElement* transport_tag =
-          new XmlElement(QName(kIceTransportNamespace, "transport"), true);
-      content_tag->AddElement(transport_tag);
-      for (const IceCredentials& credentials : ice_credentials) {
-        transport_tag->AddElement(FormatIceCredentials(credentials));
-      }
-      for (const NamedCandidate& candidate : candidates) {
-        transport_tag->AddElement(FormatIceCandidate(candidate));
-      }
-    }
+    if (transport_info)
+      content_tag->AddElement(new XmlElement(*transport_info));
   }
 
   return root.Pass();
 }
 
 JingleMessageReply::JingleMessageReply()
     : type(REPLY_RESULT),
       error_type(NONE) {
 }
 
@@ skipping 86 matching lines @@
     buzz::XmlElement* text_elem =
             new buzz::XmlElement(QName(kJabberNamespace, "text"));
     text_elem->SetAttr(QName(kXmlNamespace, "lang"), "en");
     text_elem->SetBodyText(error_text);
     error->AddElement(text_elem);
   }
 
   return iq.Pass();
 }
 
+IceTransportInfo::IceTransportInfo() {}
+IceTransportInfo::~IceTransportInfo() {}
+
+bool IceTransportInfo::ParseXml(
+    const buzz::XmlElement* element) {
+  if (element->Name() != QName(kIceTransportNamespace, "transport"))
+    return false;
+
+  ice_credentials.clear();
+  candidates.clear();
+
+  QName qn_credentials(kIceTransportNamespace, "credentials");
+  for (const XmlElement* credentials_tag = element->FirstNamed(qn_credentials);
+       credentials_tag;
+       credentials_tag = credentials_tag->NextNamed(qn_credentials)) {
+    IceTransportInfo::IceCredentials credentials;
+    if (!ParseIceCredentials(credentials_tag, &credentials))
+      return false;
+    ice_credentials.push_back(credentials);
+  }
+
+  QName qn_candidate(kIceTransportNamespace, "candidate");
+  for (const XmlElement* candidate_tag = element->FirstNamed(qn_candidate);
+       candidate_tag; candidate_tag = candidate_tag->NextNamed(qn_candidate)) {
+    IceTransportInfo::NamedCandidate candidate;
+    if (!ParseIceCandidate(candidate_tag, &candidate))
+      return false;
+    candidates.push_back(candidate);
+  }
+
+  return true;
+}
+
+scoped_ptr<buzz::XmlElement> IceTransportInfo::ToXml() const {
+  scoped_ptr<buzz::XmlElement> result(
+      new XmlElement(QName(kIceTransportNamespace, "transport"), true));
+  for (const IceCredentials& credentials : ice_credentials) {
+    result->AddElement(FormatIceCredentials(credentials));
+  }
+  for (const NamedCandidate& candidate : candidates) {
+    result->AddElement(FormatIceCandidate(candidate));
+  }
+  return result.Pass();
+}
+
 }  // namespace protocol
 }  // namespace remoting