Refactor SignalStrategy so that it can be reused for multiple connections.

remoting/protocol/pepper_session_unittest.cc

 // Copyright (c) 2011 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/pepper_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/test/test_timeouts.h"
@@ skipping 25 matching lines @@
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const char kHostJid[] = "host1@gmail.com/123";
 const char kClientJid[] = "host2@gmail.com/321";
 
 class MockSessionManagerListener : public SessionManager::Listener {
  public:
-  MOCK_METHOD0(OnSessionManagerInitialized, void());
+  MOCK_METHOD0(OnSessionManagerReady, void());
   MOCK_METHOD2(OnIncomingSession,
                void(Session*,
                     SessionManager::IncomingSessionResponse*));
 };
 
 class MockSessionCallback {
  public:
   MOCK_METHOD1(OnStateChange, void(Session::State));
 };
 
@@ skipping 30 matching lines @@
     client_session_.reset();
   }
 
   void CreateSessionManagers(int auth_round_trips,
                         FakeAuthenticator::Action auth_action) {
     host_signal_strategy_.reset(new FakeSignalStrategy(kHostJid));
     client_signal_strategy_.reset(new FakeSignalStrategy(kClientJid));
     FakeSignalStrategy::Connect(host_signal_strategy_.get(),
                                 client_signal_strategy_.get());
 
-    EXPECT_CALL(host_server_listener_, OnSessionManagerInitialized())
+    EXPECT_CALL(host_server_listener_, OnSessionManagerReady())
         .Times(1);
     host_server_.reset(new JingleSessionManager(
         base::MessageLoopProxy::current()));
     host_server_->Init(
-        kHostJid, host_signal_strategy_.get(), &host_server_listener_, false);
+        host_signal_strategy_.get(), &host_server_listener_, false);
 
     host_server_->set_authenticator_factory(
         new FakeHostAuthenticatorFactory(auth_round_trips, auth_action, true));
 
-    EXPECT_CALL(client_server_listener_, OnSessionManagerInitialized())
+    EXPECT_CALL(client_server_listener_, OnSessionManagerReady())
         .Times(1);
     client_server_.reset(new PepperSessionManager(NULL));
     client_server_->Init(
-        kClientJid, client_signal_strategy_.get(),
-        &client_server_listener_, false);
+        client_signal_strategy_.get(), &client_server_listener_, false);
   }
 
   void CloseSessionManager() {
     if (host_server_.get()) {
       host_server_->Close();
       host_server_.reset();
     }
     if (client_server_.get()) {
       client_server_->Close();
       client_server_.reset();
@@ skipping 140 matching lines @@
 }
 
 // Verify that connection is terminated when multi-step auth fails.
 TEST_F(PepperSessionTest, ConnectWithBadMultistepAuth) {
   CreateSessionManagers(3, FakeAuthenticator::REJECT);
   InitiateConnection(3, FakeAuthenticator::ACCEPT, true);
 }
 
 }  // namespace protocol
 }  // namespace remoting