Move SignalingAddress to remoting/signaling

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/base/name_value_map.h"
 #include "remoting/base/remoting_bot.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/session_plugin.h"
-#include "remoting/signaling/jid_util.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const char kJabberNamespace[] = "jabber:client";
 const char kJingleNamespace[] = "urn:xmpp:jingle:1";
 
 // Namespace for transport messages when using standard ICE.
 const char kIceTransportNamespace[] = "google:remoting:ice";
 
 const char kWebrtcTransportNamespace[] = "google:remoting:webrtc";
 
 const char kEmptyNamespace[] = "";
 const char kXmlNamespace[] = "http://www.w3.org/XML/1998/namespace";
 
 const int kPortMin = 1000;
 const int kPortMax = 65535;
 
-const NameMapElement<SignalingAddress::Channel> kChannelTypes[] = {
-    {SignalingAddress::Channel::LCS, "lcs"},
-    {SignalingAddress::Channel::XMPP, "xmpp"},
-};
-
 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 90 matching lines @@
   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;
 }
 
-// Represents the XML attrbute names for the various address fields in the
-// iq stanza.
-enum class Field { JID, CHANNEL, ENDPOINT_ID };
-
-buzz::QName GetQNameByField(Field attr, bool from) {
-  std::string attribute_name;
-  switch (attr) {
-    case Field::JID:
-      attribute_name = (from) ? "from" : "to";
-      break;
-    case Field::ENDPOINT_ID:
-      attribute_name = (from) ? "from-endpoint-id" : "to-endpoint-id";
-      break;
-    case Field::CHANNEL:
-      attribute_name = (from) ? "from-channel" : "to-channel";
-      break;
-    default:
-      NOTREACHED();
-  }
-  return QName(kEmptyNamespace, attribute_name);
-}
-
-SignalingAddress ParseAddress(
-    const buzz::XmlElement* iq, bool from, std::string* error) {
-  std::string jid(iq->Attr(GetQNameByField(Field::JID, from)));
-  if (jid.empty()) {
-    return SignalingAddress();
-  }
-
-  const XmlElement* jingle = iq->FirstNamed(QName(kJingleNamespace, "jingle"));
-
-  if (!jingle) {
-    return SignalingAddress(jid);
-  }
-
-  std::string type(iq->Attr(QName(std::string(), "type")));
-  // For error IQs, flips the |from| flag as the jingle node represents the
-  // original request.
-  if (type == "error") {
-    from = !from;
-  }
-
-  std::string endpoint_id(
-      jingle->Attr(GetQNameByField(Field::ENDPOINT_ID, from)));
-  std::string channel_str(jingle->Attr(GetQNameByField(Field::CHANNEL, from)));
-  SignalingAddress::Channel channel;
-
-  if (channel_str.empty()) {
-    channel = SignalingAddress::Channel::XMPP;
-  } else if (!NameToValue(kChannelTypes, channel_str, &channel)) {
-    *error = "Unknown channel: " + channel_str;
-    return SignalingAddress();
-  }
-
-  bool is_lcs = (channel == SignalingAddress::Channel::LCS);
-
-  if (is_lcs == endpoint_id.empty()) {
-    *error = (is_lcs ? "Missing |endpoint-id| for LCS channel"
-                    : "|endpoint_id| should be empty for XMPP channel");
-    return SignalingAddress();
-  }
-
-  if (from && is_lcs && !IsValidBotJid(jid)) {
-    *error = "Reject LCS message from untrusted sender: " + jid;
-    return SignalingAddress();
-  }
-
-  return SignalingAddress(jid, endpoint_id, channel);
-}
-
-void SetAddress(buzz::XmlElement* iq,
-                buzz::XmlElement* jingle,
-                const SignalingAddress& address,
-                bool from) {
-  if (address.empty()) {
-    return;
-  }
-
-  // Always set the JID.
-  iq->SetAttr(GetQNameByField(Field::JID, from), address.jid());
-
-  // Do not tamper the routing-info in the jingle tag for error IQ's, as
-  // it corresponds to the original message.
-  std::string type(iq->Attr(QName(std::string(), "type")));
-  if (type == "error") {
-    return;
-  }
-
-  // Start from a fresh slate regardless of the previous address format.
-  jingle->ClearAttr(GetQNameByField(Field::CHANNEL, from));
-  jingle->ClearAttr(GetQNameByField(Field::ENDPOINT_ID, from));
-
-  // Only set the channel and endpoint_id in the LCS channel.
-  if (address.channel() == SignalingAddress::Channel::LCS) {
-    jingle->AddAttr(GetQNameByField(Field::ENDPOINT_ID, from),
-                    address.endpoint_id());
-    jingle->AddAttr(GetQNameByField(Field::CHANNEL, from),
-                    ValueToName(kChannelTypes, address.channel()));
-  }
-}
-
 }  // namespace
 
-SignalingAddress::SignalingAddress()
-    : channel_(SignalingAddress::Channel::XMPP) {}
-
-SignalingAddress::SignalingAddress(const std::string& jid)
-    : jid_(NormalizeJid(jid)), channel_(SignalingAddress::Channel::XMPP) {
-  DCHECK(!jid.empty());
-}
-
-SignalingAddress::SignalingAddress(const std::string& jid,
-                                   const std::string& endpoint_id,
-                                   Channel channel)
-    : jid_(NormalizeJid(jid)),
-      endpoint_id_(NormalizeJid(endpoint_id)),
-      channel_(channel) {
-  DCHECK(!jid.empty());
-}
-
-bool SignalingAddress::operator==(const SignalingAddress& other) const {
-  return (other.jid_ == jid_) && (other.endpoint_id_ == endpoint_id_) &&
-         (other.channel_ == channel_);
-}
-
-bool SignalingAddress::operator!=(const SignalingAddress& other) const {
-  return !(*this == other);
-}
-
 // 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;
 }
 
 // static
 std::string JingleMessage::GetActionName(ActionType action) {
   return ValueToName(kActionTypes, action);
@@ skipping 15 matching lines @@
     return false;
   }
 
   const XmlElement* jingle_tag =
       stanza->FirstNamed(QName(kJingleNamespace, "jingle"));
   if (!jingle_tag) {
     *error = "Not a jingle message";
     return false;
   }
 
-  from = ParseAddress(stanza, true, error);
-  if (!error->empty()) {
+  from = SignalingAddress::Parse(stanza, SignalingAddress::FROM, error);
+  to = SignalingAddress::Parse(stanza, SignalingAddress::TO, error);
+  if (from.empty() || to.empty()) {
     return false;
   }
 
-  to = ParseAddress(stanza, false, error);
-  if (!error->empty()) {
-    return false;
-  }
-
   initiator = jingle_tag->Attr(QName(kEmptyNamespace, "initiator"));
 
   std::string action_str = jingle_tag->Attr(QName(kEmptyNamespace, "action"));
   if (action_str.empty()) {
     *error = "action attribute is missing";
     return false;
   }
   if (!NameToValue(kActionTypes, action_str, &action)) {
     *error = "Unknown action " + action_str;
     return false;
@@ skipping 105 matching lines @@
   std::unique_ptr<XmlElement> root(
       new XmlElement(QName("jabber:client", "iq"), true));
 
   DCHECK(!to.empty());
   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);
-  SetAddress(root.get(), jingle_tag, to, false);
-  SetAddress(root.get(), jingle_tag, from, true);
+
+  to.SetInMessage(root.get(), SignalingAddress::TO);
+  if (!from.empty())
+    from.SetInMessage(root.get(), SignalingAddress::FROM);
 
   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 (attachments) {
     jingle_tag->AddElement(new XmlElement(*attachments));
   }
@@ skipping 78 matching lines @@
 std::unique_ptr<buzz::XmlElement> JingleMessageReply::ToXml(
     const buzz::XmlElement* request_stanza) const {
   std::unique_ptr<XmlElement> iq(
       new XmlElement(QName(kJabberNamespace, "iq"), true));
 
   iq->SetAttr(QName(kEmptyNamespace, "id"),
               request_stanza->Attr(QName(kEmptyNamespace, "id")));
 
   SignalingAddress original_from;
   std::string error_message;
-  original_from = ParseAddress(request_stanza, true, &error_message);
-  DCHECK(error_message.empty());
+  original_from = SignalingAddress::Parse(
+      request_stanza, SignalingAddress::FROM, &error_message);
+  DCHECK(!original_from.empty());
 
   if (type == REPLY_RESULT) {
     iq->SetAttr(QName(kEmptyNamespace, "type"), "result");
     XmlElement* jingle =
         new XmlElement(QName(kJingleNamespace, "jingle"), true);
     iq->AddElement(jingle);
-    SetAddress(iq.get(), jingle, original_from, false);
+    original_from.SetInMessage(iq.get(), SignalingAddress::TO);
     return iq;
   }
 
   DCHECK_EQ(type, REPLY_ERROR);
 
   iq->SetAttr(QName(kEmptyNamespace, "type"), "error");
-  SetAddress(iq.get(), nullptr, original_from, false);
+  original_from.SetInMessage(iq.get(), SignalingAddress::TO);
 
   for (const buzz::XmlElement* child = request_stanza->FirstElement();
        child != nullptr; child = child->NextElement()) {
     iq->AddElement(new buzz::XmlElement(*child));
   }
 
   buzz::XmlElement* error =
       new buzz::XmlElement(QName(kJabberNamespace, "error"));
   iq->AddElement(error);
 
@@ skipping 106 matching lines @@
     result->AddElement(FormatIceCredentials(credentials));
   }
   for (const NamedCandidate& candidate : candidates) {
     result->AddElement(FormatIceCandidate(candidate));
   }
   return result;
 }
 
 }  // namespace protocol
 }  // namespace remoting