More cleanups in JingleSessionManager interface.

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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 30 matching lines @@
 using testing::WithArg;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const char kHostJid[] = "host1@gmail.com/123";
 const char kClientJid[] = "host2@gmail.com/321";
 
-class MockSessionManagerListener : public SessionManager::Listener {
+class MockSessionManagerListener {
  public:
   MOCK_METHOD2(OnIncomingSession,
                void(Session*,
                     SessionManager::IncomingSessionResponse*));
 };
 
 class MockSessionEventHandler : public Session::EventHandler {
  public:
   MOCK_METHOD1(OnSessionStateChange, void(Session::State));
   MOCK_METHOD2(OnSessionRouteChange, void(const std::string& channel_name,
@@ skipping 37 matching lines @@
   void CreateSessionManagers(int auth_round_trips, int messages_till_start,
                              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());
 
     host_server_.reset(new JingleSessionManager(
         make_scoped_ptr(new IceTransportFactory(new TransportContext(
             nullptr, make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)),
-            network_settings_, TransportRole::SERVER)))));
-    host_server_->Init(host_signal_strategy_.get(), &host_server_listener_);
+            network_settings_, TransportRole::SERVER))),
+        host_signal_strategy_.get()));
+    host_server_->AcceptIncoming(
+        base::Bind(&MockSessionManagerListener::OnIncomingSession,
+                   base::Unretained(&host_server_listener_)));
 
     scoped_ptr<AuthenticatorFactory> factory(
         new FakeHostAuthenticatorFactory(auth_round_trips,
           messages_till_start, auth_action, true));
     host_server_->set_authenticator_factory(factory.Pass());
 
     client_server_.reset(new JingleSessionManager(
         make_scoped_ptr(new IceTransportFactory(new TransportContext(
             nullptr, make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)),
-            network_settings_, TransportRole::CLIENT)))));
-    client_server_->Init(client_signal_strategy_.get(),
-                         &client_server_listener_);
+            network_settings_, TransportRole::CLIENT))),
+        client_signal_strategy_.get()));
   }
 
   void CreateSessionManagers(int auth_round_trips,
                              FakeAuthenticator::Action auth_action) {
     CreateSessionManagers(auth_round_trips, 0, auth_action);
   }
 
   void CloseSessionManager() {
-    if (host_server_.get()) {
-      host_server_->Close();
-      host_server_.reset();
-    }
-    if (client_server_.get()) {
-      client_server_->Close();
-      client_server_.reset();
-    }
+    host_server_.reset();
+    client_server_.reset();
     host_signal_strategy_.reset();
     client_signal_strategy_.reset();
   }
 
   void InitiateConnection(int auth_round_trips,
                           FakeAuthenticator::Action auth_action,
                           bool expect_fail) {
     EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
         .WillOnce(DoAll(
             WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
@@ skipping 68 matching lines @@
   scoped_ptr<base::MessageLoopForIO> message_loop_;
 
   NetworkSettings network_settings_;
 
   scoped_ptr<FakeSignalStrategy> host_signal_strategy_;
   scoped_ptr<FakeSignalStrategy> client_signal_strategy_;
 
   scoped_ptr<JingleSessionManager> host_server_;
   MockSessionManagerListener host_server_listener_;
   scoped_ptr<JingleSessionManager> client_server_;
-  MockSessionManagerListener client_server_listener_;
 
   scoped_ptr<Session> host_session_;
   MockSessionEventHandler host_session_event_handler_;
   scoped_ptr<Session> client_session_;
   MockSessionEventHandler client_session_event_handler_;
 };
 
 
 // Verify that we can create and destroy session managers without a
 // connection.
@@ skipping 164 matching lines @@
 
 // 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));
 }
 
 }  // namespace protocol
 }  // namespace remoting