Update SignalingAddress to normalize all JIDs.

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"
 #include "remoting/protocol/name_value_map.h"
+#include "remoting/signaling/jid_util.h"
 #include "remoting/signaling/remoting_bot.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
@@ skipping 144 matching lines @@
       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) {
-  SignalingAddress empty_instance;
-
   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 empty_instance;
+    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 empty_instance;
+    return SignalingAddress();
   }
 
   if (from && is_lcs && !IsValidBotJid(jid)) {
     *error = "Reject LCS message from untrusted sender: " + jid;
-    return empty_instance;
+    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);
+  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));
+  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
 
-IceTransportInfo::NamedCandidate::NamedCandidate(
-    const std::string& name,
-    const cricket::Candidate& candidate)
-    : name(name),
-      candidate(candidate) {
-}
-
-IceTransportInfo::IceCredentials::IceCredentials(std::string channel,
-                                              std::string ufrag,
-                                              std::string password)
-    : channel(channel), ufrag(ufrag), password(password) {
-}
-
 SignalingAddress::SignalingAddress()
-    : channel(SignalingAddress::Channel::XMPP) {}
+    : channel_(SignalingAddress::Channel::XMPP) {}
 
 SignalingAddress::SignalingAddress(const std::string& jid)
-    : jid(jid), channel(SignalingAddress::Channel::XMPP) {}
+    : jid_(NormalizeJid(jid)), channel_(SignalingAddress::Channel::XMPP) {
+  DCHECK(!jid.empty());
+}
 
 SignalingAddress::SignalingAddress(const std::string& jid,
                                    const std::string& endpoint_id,
                                    Channel channel)
-    : jid(jid), endpoint_id(endpoint_id), channel(channel) {}
-
-bool SignalingAddress::operator==(const SignalingAddress& other) {
-  return (other.endpoint_id == endpoint_id) && (other.jid == jid) &&
-         (other.channel == channel);
+    : jid_(NormalizeJid(jid)),
+      endpoint_id_(NormalizeJid(endpoint_id)),
+      channel_(channel) {
+  DCHECK(!jid.empty());
 }
 
-bool SignalingAddress::operator!=(const SignalingAddress& other) {
+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;
 }
 
@@ skipping 326 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;
 }
 
+IceTransportInfo::NamedCandidate::NamedCandidate(
+    const std::string& name,
+    const cricket::Candidate& candidate)
+    : name(name), candidate(candidate) {}
+
+IceTransportInfo::IceCredentials::IceCredentials(std::string channel,
+                                                 std::string ufrag,
+                                                 std::string password)
+    : channel(channel), ufrag(ufrag), password(password) {}
+
 IceTransportInfo::IceTransportInfo() {}
 IceTransportInfo::~IceTransportInfo() {}
 
 bool IceTransportInfo::ParseXml(
     const buzz::XmlElement* element) {
   if (element->Name() != QName(kIceTransportNamespace, "transport")) {
     return false;
   }
 
   ice_credentials.clear();
@@ skipping 30 matching lines @@
     result->AddElement(FormatIceCredentials(credentials));
   }
   for (const NamedCandidate& candidate : candidates) {
     result->AddElement(FormatIceCandidate(candidate));
   }
   return result;
 }
 
 }  // namespace protocol
 }  // namespace remoting