Use SignalingAddress in SignalStrategy insterface.

remoting/protocol/jingle_session_unittest.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_session.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 34 matching lines @@
 using testing::Return;
 using testing::SaveArg;
 using testing::SetArgumentPointee;
 using testing::WithArg;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const char kHostJid[] = "host@gmail.com/123";

[joedow, 2017/04/10 16:46:42]

Do we already have unit tests for mixed case JIDs at the appropriate level in
the stack?

[Sergey Ulanov, 2017/04/10 19:58:03]

We have unittests, but they use FakeAuthenticator, which doesn't verify that the
same peer identities are passed on the both ends, so these tests didn't catch
this issue. I'll fix this in a separate CL.

 const char kClientJid[] = "client@gmail.com/321";
 
 class MockSessionManagerListener {
  public:
   MOCK_METHOD2(OnIncomingSession,
                void(Session*,
                     SessionManager::IncomingSessionResponse*));
 };
 
 class MockSessionEventHandler : public Session::EventHandler {
@@ skipping 111 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   void CloseSessions() {
     host_session_.reset();
     client_session_.reset();
   }
 
   void CreateSessionManagers(int auth_round_trips, int messages_till_start,
                              FakeAuthenticator::Action auth_action) {
-    if (!host_signal_strategy_)
-      host_signal_strategy_.reset(new FakeSignalStrategy(kHostJid));
-    if (!client_signal_strategy_)
-      client_signal_strategy_.reset(new FakeSignalStrategy(kClientJid));
+    if (!host_signal_strategy_) {
+      host_signal_strategy_.reset(
+          new FakeSignalStrategy(SignalingAddress(kHostJid)));
+    }
+    if (!client_signal_strategy_) {
+      client_signal_strategy_.reset(
+          new FakeSignalStrategy(SignalingAddress(kClientJid)));
+    }
     FakeSignalStrategy::Connect(host_signal_strategy_.get(),
                                 client_signal_strategy_.get());
 
     host_server_.reset(new JingleSessionManager(host_signal_strategy_.get()));
     host_server_->AcceptIncoming(
         base::Bind(&MockSessionManagerListener::OnIncomingSession,
                    base::Unretained(&host_server_listener_)));
 
     std::unique_ptr<AuthenticatorFactory> factory(
         new FakeHostAuthenticatorFactory(auth_round_trips, messages_till_start,
@@ skipping 65 matching lines @@
                   OnSessionStateChange(Session::AUTHENTICATED))
           .Times(1);
       // Expect that the connection will be closed eventually.
       EXPECT_CALL(client_session_event_handler_,
                   OnSessionStateChange(Session::CLOSED))
           .Times(AtMost(1));
     }
   }
 
   void ConnectClient(std::unique_ptr<Authenticator> authenticator) {
-    client_session_ =
-        client_server_->Connect(host_jid_, std::move(authenticator));
+    client_session_ = client_server_->Connect(SignalingAddress(host_jid_),
+                                              std::move(authenticator));
     client_session_->SetEventHandler(&client_session_event_handler_);
     client_session_->SetTransport(&client_transport_);
     client_session_->AddPlugin(&client_plugin_);
     base::RunLoop().RunUntilIdle();
   }
 
   void InitiateConnection(int auth_round_trips,
                           FakeAuthenticator::Action auth_action,
                           bool expect_fail) {
     SetHostExpectation(expect_fail);
@@ skipping 69 matching lines @@
 
   {
     InSequence dummy;
     EXPECT_CALL(client_session_event_handler_,
                 OnSessionStateChange(Session::FAILED))
         .Times(1);
   }
 
   std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 1, FakeAuthenticator::ACCEPT, true));
-  client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
+  client_session_ = client_server_->Connect(SignalingAddress(kHostJid),
+                                            std::move(authenticator));
   client_session_->SetEventHandler(&client_session_event_handler_);
 
   base::RunLoop().RunUntilIdle();
 }
 
 // Verify that we can connect two endpoints with single-step authentication.
 TEST_F(JingleSessionTest, Connect) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
 
   // Verify that the client specified correct initiator value.
   ASSERT_GT(host_signal_strategy_->received_messages().size(), 0U);
   const buzz::XmlElement* initiate_xml =
       host_signal_strategy_->received_messages().front();
   const buzz::XmlElement* jingle_element =
       initiate_xml->FirstNamed(buzz::QName("urn:xmpp:jingle:1", "jingle"));
   ASSERT_TRUE(jingle_element);
   ASSERT_EQ(kClientJid,
             jingle_element->Attr(buzz::QName(std::string(), "initiator")));
 }
 
 TEST_F(JingleSessionTest, MixedCaseHostJid) {
   std::string host_jid = std::string("A") + kHostJid;
-  host_signal_strategy_.reset(new FakeSignalStrategy(host_jid));
+  host_signal_strategy_.reset(
+      new FakeSignalStrategy(SignalingAddress(host_jid)));
 
   // Imitate host JID being lower-cased when stored in the directory.
   host_jid_ = base::ToLowerASCII(host_jid);
 
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
 }
 
 TEST_F(JingleSessionTest, MixedCaseClientJid) {
   client_signal_strategy_.reset(
-      new FakeSignalStrategy(std::string("A") + kClientJid));
+      new FakeSignalStrategy(SignalingAddress(std::string("A") + kClientJid)));
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
 }
 
 // Verify that we can connect two endpoints with multi-step authentication.
 TEST_F(JingleSessionTest, ConnectWithMultistep) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
   InitiateConnection(3, FakeAuthenticator::ACCEPT, false);
 }
 
@@ skipping 56 matching lines @@
       .Times(1);
 
   std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 1, FakeAuthenticator::ACCEPT, true));
 
   std::unique_ptr<CandidateSessionConfig> config =
       CandidateSessionConfig::CreateDefault();
   // Disable all video codecs so the host will reject connection.
   config->mutable_video_configs()->clear();
   client_server_->set_protocol_config(std::move(config));
-  client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
+  client_session_ = client_server_->Connect(SignalingAddress(kHostJid),
+                                            std::move(authenticator));
   client_session_->SetEventHandler(&client_session_event_handler_);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(INCOMPATIBLE_PROTOCOL, client_session_->error());
   EXPECT_FALSE(host_session_);
 }
 
 // Verify that GICE-only client is rejected with an appropriate error code.
 TEST_F(JingleSessionTest, TestLegacyIceConnection) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _)).Times(0);
 
   EXPECT_CALL(client_session_event_handler_,
               OnSessionStateChange(Session::FAILED))
       .Times(1);
 
   std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 1, FakeAuthenticator::ACCEPT, true));
 
   std::unique_ptr<CandidateSessionConfig> config =
       CandidateSessionConfig::CreateDefault();
   config->set_ice_supported(false);
   client_server_->set_protocol_config(std::move(config));
-  client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
+  client_session_ = client_server_->Connect(SignalingAddress(kHostJid),
+                                            std::move(authenticator));
   client_session_->SetEventHandler(&client_session_event_handler_);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(INCOMPATIBLE_PROTOCOL, client_session_->error());
   EXPECT_FALSE(host_session_);
 }
 
 TEST_F(JingleSessionTest, DeleteSessionOnIncomingConnection) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
       .WillOnce(DoAll(
           WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
           SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::ACCEPTED))
       .Times(AtMost(1));
 
   EXPECT_CALL(host_session_event_handler_,
               OnSessionStateChange(Session::AUTHENTICATING))
       .WillOnce(InvokeWithoutArgs(this, &JingleSessionTest::DeleteHostSession));
 
   std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 3, FakeAuthenticator::ACCEPT, true));
 
-  client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
+  client_session_ = client_server_->Connect(SignalingAddress(kHostJid),
+                                            std::move(authenticator));
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(JingleSessionTest, DeleteSessionOnAuth) {
   // Same as the previous test, but set messages_till_started to 2 in
   // CreateSessionManagers so that the session will goes into the
   // AUTHENTICATING state after two message exchanges.
   CreateSessionManagers(3, 2, FakeAuthenticator::ACCEPT);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
       .WillOnce(
           DoAll(WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
                 SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::ACCEPTED))
       .Times(AtMost(1));
 
   EXPECT_CALL(host_session_event_handler_,
               OnSessionStateChange(Session::AUTHENTICATING))
       .WillOnce(InvokeWithoutArgs(this, &JingleSessionTest::DeleteHostSession));
 
   std::unique_ptr<Authenticator> authenticator(new FakeAuthenticator(
       FakeAuthenticator::CLIENT, 3, FakeAuthenticator::ACCEPT, true));
 
-  client_session_ = client_server_->Connect(kHostJid, std::move(authenticator));
+  client_session_ = client_server_->Connect(SignalingAddress(kHostJid),
+                                            std::move(authenticator));
   base::RunLoop().RunUntilIdle();
 }
 
 // Verify that we can connect with multistep authentication.
 TEST_F(JingleSessionTest, TestMultistepAuth) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(3, FakeAuthenticator::ACCEPT, false));
 }
 
@@ skipping 60 matching lines @@
   InitiateConnection(1, FakeAuthenticator::ACCEPT, true);
   // It's expected the client sends one more plugin message than host, the host
   // won't send plugin message in the SESSION_TERMINATE message.
   ASSERT_EQ(client_plugin_.outgoing_messages().size() - 1,
             client_plugin_.incoming_messages().size());
   ExpectPluginMessagesEqual();
 }
 
 TEST_F(JingleSessionTest, ImmediatelyCloseSessionAfterConnect) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
-  client_session_ = client_server_->Connect(host_jid_,
-      base::MakeUnique<FakeAuthenticator>(
-          FakeAuthenticator::CLIENT, 3, FakeAuthenticator::ACCEPT, true));
+  client_session_ = client_server_->Connect(
+      SignalingAddress(host_jid_),
+      base::MakeUnique<FakeAuthenticator>(FakeAuthenticator::CLIENT, 3,
+                                          FakeAuthenticator::ACCEPT, true));
   client_session_->Close(HOST_OVERLOAD);
   base::RunLoop().RunUntilIdle();
   // We should only send a SESSION_TERMINATE message if the session has been
   // closed before SESSION_INITIATE message.
   ASSERT_EQ(1U, host_signal_strategy_->received_messages().size());
 }
 
 }  // namespace protocol
 }  // namespace remoting