[remoting] Refactor jid_util

This CL renames jid_util.* to signaling_id_util.* and renames its
functions from Jid to SignalingId.

Bug: 983282
Change-Id: I94b50afc6b9c33031905e17c5c55ada3d846e9a0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1853868Reviewed-by: Jamie Walch <jamiewalch@chromium.org>
Commit-Queue: Yuwei Huang <yuweih@chromium.org>
Cr-Commit-Position: refs/heads/master@{#704827}

remoting/client/chromoting_client.cc

@@ -20,8 +20,8 @@
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_renderer.h"
 #include "remoting/protocol/webrtc_connection_to_host.h"
-#include "remoting/signaling/jid_util.h"
 #include "remoting/signaling/signaling_address.h"
+#include "remoting/signaling/signaling_id_util.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
@@ -73,7 +73,7 @@ void ChromotingClient::Start(
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!session_manager_);  // Start must not be called more than once.
 
-  host_jid_ = NormalizeJid(host_jid);
+  host_jid_ = NormalizeSignalingId(host_jid);
   local_capabilities_ = capabilities;
 
   if (!protocol_config_) {

remoting/host/it2me/it2me_host.cc

@@ -37,8 +37,8 @@
 #include "remoting/protocol/network_settings.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/validating_authenticator.h"
-#include "remoting/signaling/jid_util.h"
 #include "remoting/signaling/log_to_server.h"
+#include "remoting/signaling/signaling_id_util.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 
 namespace remoting {
@@ -224,7 +224,7 @@ void It2MeHost::OnAccessDenied(const std::string& jid) {
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts) {
     DisconnectOnNetworkThread();
-  } else if (connecting_jid_ == NormalizeJid(jid)) {
+  } else if (connecting_jid_ == NormalizeSignalingId(jid)) {
     DCHECK_EQ(state_, kConnecting);
     connecting_jid_.clear();
     confirmation_dialog_proxy_.reset();
@@ -240,7 +240,7 @@ void It2MeHost::OnClientConnected(const std::string& jid) {
   CHECK_NE(state_, kConnected);
 
   std::string client_username;
-  if (!SplitJidResource(jid, &client_username, /*resource=*/nullptr)) {
+  if (!SplitSignalingIdResource(jid, &client_username, /*resource=*/nullptr)) {
     LOG(WARNING) << "Incorrectly formatted JID received: " << jid;
     client_username = jid;
   }
@@ -501,8 +501,8 @@ void It2MeHost::ValidateConnectionDetails(
 
   // First ensure the JID we received is valid.
   std::string client_username;
-  if (!SplitJidResource(original_remote_jid, &client_username,
-                        /*resource=*/nullptr)) {
+  if (!SplitSignalingIdResource(original_remote_jid, &client_username,
+                                /*resource=*/nullptr)) {
     LOG(ERROR) << "Rejecting incoming connection from " << original_remote_jid
                << ": Invalid JID.";
     result_callback.Run(
@@ -510,7 +510,7 @@ void It2MeHost::ValidateConnectionDetails(
     DisconnectOnNetworkThread();
     return;
   }
-  std::string remote_jid = NormalizeJid(original_remote_jid);
+  std::string remote_jid = NormalizeSignalingId(original_remote_jid);
 
   if (client_username.empty()) {
     LOG(ERROR) << "Invalid user name passed in: " << remote_jid;

remoting/host/xmpp_register_support_host_request.cc

@@ -18,9 +18,9 @@
 #include "remoting/host/host_details.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/signaling/iq_sender.h"
-#include "remoting/signaling/jid_util.h"
 #include "remoting/signaling/signal_strategy.h"
 #include "remoting/signaling/signaling_address.h"
+#include "remoting/signaling/signaling_id_util.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 #include "third_party/libjingle_xmpp/xmpp/constants.h"
 
@@ -152,7 +152,7 @@ std::unique_ptr<XmlElement> XmppRegisterSupportHostRequest::CreateSignature(
   signature_tag->AddAttr(QName(kChromotingXmlNamespace, kSignatureTimeAttr),
                          time_str);
 
-  std::string message = NormalizeJid(jid) + ' ' + time_str;
+  std::string message = NormalizeSignalingId(jid) + ' ' + time_str;
   std::string signature(key_pair_->SignMessage(message));
   signature_tag->AddText(signature);
 

remoting/protocol/me2me_host_authenticator_factory.cc

@@ -14,8 +14,8 @@
 #include "remoting/protocol/negotiating_host_authenticator.h"
 #include "remoting/protocol/rejecting_authenticator.h"
 #include "remoting/protocol/token_validator.h"
-#include "remoting/signaling/jid_util.h"
 #include "remoting/signaling/signaling_address.h"
+#include "remoting/signaling/signaling_id_util.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 
 namespace remoting {
@@ -71,8 +71,8 @@ std::unique_ptr<Authenticator>
 Me2MeHostAuthenticatorFactory::CreateAuthenticator(
     const std::string& original_local_jid,
     const std::string& original_remote_jid) {
-  std::string local_jid = NormalizeJid(original_local_jid);
-  std::string remote_jid = NormalizeJid(original_remote_jid);
+  std::string local_jid = NormalizeSignalingId(original_local_jid);
+  std::string remote_jid = NormalizeSignalingId(original_remote_jid);
 
   std::string remote_jid_prefix;
 
@@ -81,7 +81,7 @@ Me2MeHostAuthenticatorFactory::CreateAuthenticator(
     // where the host owner account does not have an email associated with it.
     // In those cases, the only guarantee we have is that JIDs for the same
     // account will have the same prefix.
-    if (!SplitJidResource(local_jid, &remote_jid_prefix, nullptr)) {
+    if (!SplitSignalingIdResource(local_jid, &remote_jid_prefix, nullptr)) {
       LOG(DFATAL) << "Invalid local JID:" << local_jid;
       return base::WrapUnique(
           new RejectingAuthenticator(Authenticator::INVALID_CREDENTIALS));
@@ -125,8 +125,8 @@ Me2MeHostAuthenticatorFactory::CreateAuthenticator(
   }
 
   if (!local_cert_.empty() && key_pair_.get()) {
-    std::string normalized_local_jid = NormalizeJid(local_jid);
-    std::string normalized_remote_jid = NormalizeJid(remote_jid);
+    std::string normalized_local_jid = NormalizeSignalingId(local_jid);
+    std::string normalized_remote_jid = NormalizeSignalingId(remote_jid);
 
     if (token_validator_factory_) {
       return NegotiatingHostAuthenticator::CreateWithThirdPartyAuth(

remoting/signaling/BUILD.gn

@@ -23,8 +23,6 @@ static_library("signaling") {
     "ftl_signal_strategy.h",
     "iq_sender.cc",
     "iq_sender.h",
-    "jid_util.cc",
-    "jid_util.h",
     "message_reception_channel.h",
     "message_tracker.cc",
     "message_tracker.h",
@@ -40,6 +38,8 @@ static_library("signaling") {
     "signal_strategy.h",
     "signaling_address.cc",
     "signaling_address.h",
+    "signaling_id_util.cc",
+    "signaling_id_util.h",
     "xmpp_log_to_server.cc",
     "xmpp_log_to_server.h",
   ]
@@ -128,13 +128,13 @@ source_set("unit_tests") {
     "ftl_registration_manager_unittest.cc",
     "ftl_signal_strategy_unittest.cc",
     "iq_sender_unittest.cc",
-    "jid_util_unittest.cc",
     "message_tracker_unittest.cc",
     "push_notification_subscriber_unittest.cc",
     "remoting_log_to_server_unittest.cc",
     "server_log_entry_unittest.cc",
     "server_log_entry_unittest.h",
     "signaling_address_unittest.cc",
+    "signaling_id_util_unittest.cc",
     "xmpp_log_to_server_unittest.cc",
   ]
 

remoting/signaling/fake_signal_strategy.cc

@@ -13,7 +13,7 @@
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "remoting/signaling/jid_util.h"
+#include "remoting/signaling/signaling_id_util.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 #include "third_party/libjingle_xmpp/xmpp/constants.h"
 

remoting/signaling/iq_sender.cc

@@ -14,8 +14,8 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "remoting/signaling/jid_util.h"
 #include "remoting/signaling/signal_strategy.h"
+#include "remoting/signaling/signaling_id_util.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 #include "third_party/libjingle_xmpp/xmpp/constants.h"
 
@@ -116,7 +116,7 @@ bool IqSender::OnSignalStrategyIncomingStanza(const jingle_xmpp::XmlElement* sta
 
   IqRequest* request = it->second;
 
-  if (NormalizeJid(request->addressee_) != NormalizeJid(from)) {
+  if (NormalizeSignalingId(request->addressee_) != NormalizeSignalingId(from)) {
     LOG(ERROR) << "Received IQ response from an invalid JID. Ignoring it."
                << " Message received from: " << from
                << " Original JID: " << request->addressee_;

remoting/signaling/push_notification_subscriber.cc

@@ -9,8 +9,8 @@
 #include "base/memory/ptr_util.h"
 #include "remoting/base/logging.h"
 #include "remoting/signaling/iq_sender.h"
-#include "remoting/signaling/jid_util.h"
 #include "remoting/signaling/signaling_address.h"
+#include "remoting/signaling/signaling_id_util.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 
 namespace remoting {
@@ -56,8 +56,8 @@ void PushNotificationSubscriber::Subscribe(const Subscription& subscription) {
           << subscription.channel << ".";
 
   std::string bare_jid;
-  SplitJidResource(signal_strategy_->GetLocalAddress().id(), &bare_jid,
-                   nullptr);
+  SplitSignalingIdResource(signal_strategy_->GetLocalAddress().id(), &bare_jid,
+                           nullptr);
 
   // Build a subscription request.
   jingle_xmpp::XmlElement* subscribe_element =

remoting/signaling/signaling_address.cc

@@ -10,7 +10,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "remoting/base/name_value_map.h"
-#include "remoting/signaling/jid_util.h"
+#include "remoting/signaling/signaling_id_util.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 
 namespace remoting {
@@ -31,7 +31,7 @@ jingle_xmpp::QName GetIdQName(SignalingAddress::Direction direction) {
 SignalingAddress::Channel GetChannelType(std::string address) {
   std::string email;
   std::string resource;
-  bool has_resource = SplitJidResource(address, &email, &resource);
+  bool has_resource = SplitSignalingIdResource(address, &email, &resource);
   if (has_resource) {
     if (resource.find(kFtlResourcePrefix) == 0) {
       return SignalingAddress::Channel::FTL;
@@ -50,7 +50,7 @@ SignalingAddress::SignalingAddress(const std::string& address) {
   switch (channel_) {
     case Channel::XMPP:
     case Channel::FTL:
-      id_ = NormalizeJid(address);
+      id_ = NormalizeSignalingId(address);
       DCHECK(!id_.empty()) << "Missing signaling ID.";
       break;
     default:
@@ -98,7 +98,7 @@ bool SignalingAddress::GetFtlInfo(std::string* username,
     return false;
   }
   std::string resource;
-  bool has_resource = SplitJidResource(id_, username, &resource);
+  bool has_resource = SplitSignalingIdResource(id_, username, &resource);
   DCHECK(has_resource);
   size_t ftl_resource_prefix_length = strlen(kFtlResourcePrefix);
   DCHECK_LT(ftl_resource_prefix_length, resource.length());

remoting/signaling/jid_util.cc → remoting/signaling/signaling_id_util.cc

-// Copyright 2015 The Chromium Authors. All rights reserved.
+// Copyright 2019 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/signaling/jid_util.h"
+#include "remoting/signaling/signaling_id_util.h"
 
 #include <stddef.h>
 
@@ -18,21 +18,21 @@ constexpr char kGooglemailDomain[] = "googlemail.com";
 
 }  // namespace
 
-std::string NormalizeJid(const std::string& jid) {
-  std::string bare_jid;
+std::string NormalizeSignalingId(const std::string& id) {
+  std::string email;
   std::string resource;
-  if (SplitJidResource(jid, &bare_jid, &resource)) {
-    std::string normalized_bare_jid = resource.find(kFtlResourcePrefix) == 0
-                                          ? GetCanonicalEmail(bare_jid)
-                                          : base::ToLowerASCII(bare_jid);
-    return normalized_bare_jid + "/" + resource;
+  if (SplitSignalingIdResource(id, &email, &resource)) {
+    std::string normalized_email = resource.find(kFtlResourcePrefix) == 0
+                                       ? GetCanonicalEmail(email)
+                                       : base::ToLowerASCII(email);
+    return normalized_email + "/" + resource;
   }
-  return base::ToLowerASCII(bare_jid);
+  return base::ToLowerASCII(email);
 }
 
 std::string GetCanonicalEmail(std::string email) {
   DCHECK(email.find('/') == std::string::npos)
-      << "You seemed to pass in a full JID. You should only pass in an email "
+      << "You seemed to pass in a full ID. You should only pass in an email "
       << "address.";
   email = base::ToLowerASCII(email);
   base::TrimString(email, base::kWhitespaceASCII, &email);
@@ -54,13 +54,13 @@ std::string GetCanonicalEmail(std::string email) {
   return email;
 }
 
-bool SplitJidResource(const std::string& full_jid,
-                      std::string* bare_jid,
-                      std::string* resource) {
-  size_t slash_index = full_jid.find('/');
+bool SplitSignalingIdResource(const std::string& full_id,
+                              std::string* email,
+                              std::string* resource) {
+  size_t slash_index = full_id.find('/');
   if (slash_index == std::string::npos) {
-    if (bare_jid) {
-      *bare_jid = full_jid;
+    if (email) {
+      *email = full_id;
     }
     if (resource) {
       resource->clear();
@@ -68,11 +68,11 @@ bool SplitJidResource(const std::string& full_jid,
     return false;
   }
 
-  if (bare_jid) {
-    *bare_jid = full_jid.substr(0, slash_index);
+  if (email) {
+    *email = full_id.substr(0, slash_index);
   }
   if (resource) {
-    *resource = full_jid.substr(slash_index + 1);
+    *resource = full_id.substr(slash_index + 1);
   }
   return true;
 }

remoting/signaling/jid_util.h → remoting/signaling/signaling_id_util.h

-// Copyright 2015 The Chromium Authors. All rights reserved.
+// Copyright 2019 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.
 
-#ifndef REMOTING_SIGNALING_JID_UTIL_H_
-#define REMOTING_SIGNALING_JID_UTIL_H_
+#ifndef REMOTING_SIGNALING_SIGNALING_ID_UTIL_H_
+#define REMOTING_SIGNALING_SIGNALING_ID_UTIL_H_
 
 #include <string>
 
 namespace remoting {
 
-// Normalizes the |jid|. If |jid| is an FTL ID then the email part will be
+// Normalizes |id|. If |id| is an FTL ID then the email part will be
 // canonicalized. Otherwise it will simply convert case-insensitive parts (node
 // and domain) to lower-case.
-std::string NormalizeJid(const std::string& jid);
+std::string NormalizeSignalingId(const std::string& id);
 
 // Returns the canonical email for the given email. Note that this only works
-// for email address (bare JID) and does not work for full JID.
+// for email address and does not work for full signaling ID.
 //
 // Canonicalizes by:
 //   * changing to lowercase
@@ -23,17 +23,17 @@ std::string NormalizeJid(const std::string& jid);
 //   * normalize email domain googlemail.com to gmail.com
 std::string GetCanonicalEmail(std::string email);
 
-// Splits a JID into a bare JID and a resource suffix.  Either |full_jid|,
-// |resource|, or both may be null.  If |full_jid| is already
-// a bare JID, |resource| is set to the empty string.  Returns true if
-// |full_jid| has a resource, false if not.
+// Splits a signaling ID into a the email and a resource suffix.  Either
+// |full_id|, |resource|, or both may be null.  If |full_id| is already an email
+// address, |resource| is set to the empty string.  Returns true if |full_id|
+// has a resource, false if not.
 //
 // e.g. "user@domain/resource" -> "user@domain", "resource", true
 //      "user@domain"          -> "user@domain", "",         false
-bool SplitJidResource(const std::string& full_jid,
-                      std::string* bare_jid,
-                      std::string* resource);
+bool SplitSignalingIdResource(const std::string& full_id,
+                              std::string* email,
+                              std::string* resource);
 
 }  // namespace remoting
 
-#endif  // REMOTING_SIGNALING_JID_UTIL_H_
+#endif  // REMOTING_SIGNALING_SIGNALING_ID_UTIL_H_

remoting/signaling/jid_util_unittest.cc → remoting/signaling/signaling_id_util_unittest.cc

-// Copyright 2015 The Chromium Authors. All rights reserved.
+// Copyright 2019 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/signaling/jid_util.h"
+#include "remoting/signaling/signaling_id_util.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
-TEST(JidUtilTest, NormalizeJid) {
-  EXPECT_EQ(NormalizeJid("USER@DOMAIN.com"), "user@domain.com");
-  EXPECT_EQ(NormalizeJid("user@domain.com"), "user@domain.com");
-  EXPECT_EQ(NormalizeJid("USER@DOMAIN.com/RESOURCE"),
+TEST(SignalingIdUtilTest, NormalizeSignalingId) {
+  EXPECT_EQ(NormalizeSignalingId("USER@DOMAIN.com"), "user@domain.com");
+  EXPECT_EQ(NormalizeSignalingId("user@domain.com"), "user@domain.com");
+  EXPECT_EQ(NormalizeSignalingId("USER@DOMAIN.com/RESOURCE"),
             "user@domain.com/RESOURCE");
-  EXPECT_EQ(NormalizeJid("USER@DOMAIN.com/"), "user@domain.com/");
+  EXPECT_EQ(NormalizeSignalingId("USER@DOMAIN.com/"), "user@domain.com/");
 
   // Jabber ID normalization
   EXPECT_EQ("user.mixed.case@googlemail.com/RESOURCE",
-            NormalizeJid("User.Mixed.Case@GOOGLEMAIL.com/RESOURCE"));
+            NormalizeSignalingId("User.Mixed.Case@GOOGLEMAIL.com/RESOURCE"));
 
   // FTL ID normalization
   EXPECT_EQ("user@domain.com/chromoting_ftl_abc123",
-            NormalizeJid("USER@DOMAIN.com/chromoting_ftl_abc123"));
+            NormalizeSignalingId("USER@DOMAIN.com/chromoting_ftl_abc123"));
   EXPECT_EQ("user@domain.com/chromoting_ftl_abc123",
-            NormalizeJid("  USER@DOMAIN.com/chromoting_ftl_abc123"));
-  EXPECT_EQ("usermixedcase@gmail.com/chromoting_ftl_abc123",
-            NormalizeJid("User.Mixed.Case@GMAIL.com/chromoting_ftl_abc123"));
+            NormalizeSignalingId("  USER@DOMAIN.com/chromoting_ftl_abc123"));
   EXPECT_EQ(
       "usermixedcase@gmail.com/chromoting_ftl_abc123",
-      NormalizeJid("User.Mixed.Case@GOOGLEMAIL.com/chromoting_ftl_abc123"));
-  EXPECT_EQ("user.mixed.case@domain.com/chromoting_ftl_abc123",
-            NormalizeJid("User.Mixed.Case@DOMAIN.com/chromoting_ftl_abc123"));
+      NormalizeSignalingId("User.Mixed.Case@GMAIL.com/chromoting_ftl_abc123"));
+  EXPECT_EQ("usermixedcase@gmail.com/chromoting_ftl_abc123",
+            NormalizeSignalingId(
+                "User.Mixed.Case@GOOGLEMAIL.com/chromoting_ftl_abc123"));
+  EXPECT_EQ(
+      "user.mixed.case@domain.com/chromoting_ftl_abc123",
+      NormalizeSignalingId("User.Mixed.Case@DOMAIN.com/chromoting_ftl_abc123"));
   EXPECT_EQ("invalid.user/chromoting_ftl_abc123",
-            NormalizeJid("  Invalid.User/chromoting_ftl_abc123"));
+            NormalizeSignalingId("  Invalid.User/chromoting_ftl_abc123"));
   EXPECT_EQ("invalid.user@/chromoting_ftl_abc123",
-            NormalizeJid("  Invalid.User@/chromoting_ftl_abc123"));
+            NormalizeSignalingId("  Invalid.User@/chromoting_ftl_abc123"));
   EXPECT_EQ("@gmail.com/chromoting_ftl_abc123",
-            NormalizeJid("@googlemail.com/chromoting_ftl_abc123"));
+            NormalizeSignalingId("@googlemail.com/chromoting_ftl_abc123"));
 }
 
-TEST(JidUtilTest, SplitJidResource) {
-  std::string bare_jid;
+TEST(SignalingIdUtilTest, SplitSignalingIdResource) {
+  std::string email;
   std::string resource_suffix;
 
-  EXPECT_TRUE(SplitJidResource("user@domain/resource", nullptr, nullptr));
   EXPECT_TRUE(
-      SplitJidResource("user@domain/resource", &bare_jid, &resource_suffix));
-  EXPECT_EQ(bare_jid, "user@domain");
+      SplitSignalingIdResource("user@domain/resource", nullptr, nullptr));
+  EXPECT_TRUE(SplitSignalingIdResource("user@domain/resource", &email,
+                                       &resource_suffix));
+  EXPECT_EQ(email, "user@domain");
   EXPECT_EQ(resource_suffix, "resource");
 
-  EXPECT_FALSE(SplitJidResource("user@domain", nullptr, nullptr));
-  EXPECT_FALSE(SplitJidResource("user@domain", &bare_jid, &resource_suffix));
-  EXPECT_EQ(bare_jid, "user@domain");
+  EXPECT_FALSE(SplitSignalingIdResource("user@domain", nullptr, nullptr));
+  EXPECT_FALSE(
+      SplitSignalingIdResource("user@domain", &email, &resource_suffix));
+  EXPECT_EQ(email, "user@domain");
   EXPECT_EQ(resource_suffix, "");
 }