More cleanups in JingleSessionManager interface.

remoting/host/chromoting_host_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/fake_desktop_environment.h"
 #include "remoting/host/fake_mouse_cursor_monitor.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/fake_connection_to_client.h"
 #include "remoting/protocol/fake_desktop_capturer.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/session_config.h"
-#include "remoting/signaling/mock_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::remoting::protocol::MockClientStub;
 using ::remoting::protocol::MockConnectionToClientEventHandler;
 using ::remoting::protocol::MockHostStub;
 using ::remoting::protocol::MockSession;
 using ::remoting::protocol::MockVideoStub;
 using ::remoting::protocol::Session;
@@ skipping 22 matching lines @@
   ChromotingHostTest() {
   }
 
   void SetUp() override {
     task_runner_ = new AutoThreadTaskRunner(message_loop_.task_runner(),
                                             base::Bind(&base::DoNothing));
 
     desktop_environment_factory_.reset(new FakeDesktopEnvironmentFactory());
     session_manager_ = new protocol::MockSessionManager();
 
-    host_.reset(new ChromotingHost(
-        &signal_strategy_,
-        desktop_environment_factory_.get(),
-        make_scoped_ptr(session_manager_),
-        task_runner_,   // Audio
-        task_runner_,   // Input
-        task_runner_,   // Video capture
-        task_runner_,   // Video encode
-        task_runner_,   // Network
-        task_runner_)); // UI
+    host_.reset(new ChromotingHost(desktop_environment_factory_.get(),
+                                   make_scoped_ptr(session_manager_),
+                                   task_runner_,    // Audio
+                                   task_runner_,    // Input
+                                   task_runner_,    // Video capture
+                                   task_runner_,    // Video encode
+                                   task_runner_,    // Network
+                                   task_runner_));  // UI
     host_->AddStatusObserver(&host_status_observer_);
 
     xmpp_login_ = "host@domain";
     session1_ = new MockSession();
     session2_ = new MockSession();
     session_unowned1_.reset(new MockSession());
     session_unowned2_.reset(new MockSession());
     session_config1_ = SessionConfig::ForTest();
     session_jid1_ = "user@domain/rest-of-jid";
     session_config2_ = SessionConfig::ForTest();
@@ skipping 98 matching lines @@
       session_unowned2_event_handler_->OnSessionStateChange(Session::CLOSED);
     }
   }
 
   void ShutdownHost() {
     EXPECT_CALL(host_status_observer_, OnShutdown());
     host_.reset();
     desktop_environment_factory_.reset();
   }
 
-  // Expect the host and session manager to start, and return the expectation
-  // that the session manager has started.
-  Expectation ExpectHostAndSessionManagerStart() {
+  // Starts the host.
+  void StartHost() {
     EXPECT_CALL(host_status_observer_, OnStart(xmpp_login_));
-    return EXPECT_CALL(*session_manager_, Init(_, host_.get()));
+    EXPECT_CALL(*session_manager_, AcceptIncoming(_));
+    host_->Start(xmpp_login_);
   }
 
   // Expect a client to connect.
   // Return an expectation that a session has started.
   Expectation ExpectClientConnected(int connection_index) {
     const std::string& session_jid = get_session_jid(connection_index);
 
     Expectation client_authenticated =
         EXPECT_CALL(host_status_observer_, OnClientAuthenticated(session_jid));
     return EXPECT_CALL(host_status_observer_, OnClientConnected(session_jid))
         .After(client_authenticated);
   }
 
   // Expect that a client is disconnected. The given action will be done after
   // the status observer is notified that the session has finished.
   Expectation ExpectClientDisconnected(int connection_index) {
     return EXPECT_CALL(host_status_observer_,
                        OnClientDisconnected(get_session_jid(connection_index)))
         .RetiresOnSaturation();
   }
 
  protected:
   base::MessageLoop message_loop_;
   scoped_refptr<AutoThreadTaskRunner> task_runner_;
   MockConnectionToClientEventHandler handler_;
-  MockSignalStrategy signal_strategy_;
   scoped_ptr<FakeDesktopEnvironmentFactory> desktop_environment_factory_;
   MockHostStatusObserver host_status_observer_;
   scoped_ptr<ChromotingHost> host_;
   protocol::MockSessionManager* session_manager_;
   std::string xmpp_login_;
   protocol::FakeConnectionToClient* connection1_;
   scoped_ptr<protocol::FakeConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
   MockSession* session1_;  // Owned by |connection_|.
@@ skipping 28 matching lines @@
   std::list<ClientSession*>& get_clients_from_host() {
     return host_->clients_;
   }
 
   const std::string& get_session_jid(int connection_index) {
     return (connection_index == 0) ? session_jid1_ : session_jid2_;
   }
 };
 
 TEST_F(ChromotingHostTest, StartAndShutdown) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 }
 
 TEST_F(ChromotingHostTest, Connect) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 
   // Shut down the host when the first video packet is received.
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 }
 
 TEST_F(ChromotingHostTest, AuthenticationFailed) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 
   EXPECT_CALL(host_status_observer_, OnAccessDenied(session_jid1_));
   SimulateClientConnection(0, false, false);
 }
 
 TEST_F(ChromotingHostTest, Reconnect) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 
   // Connect first client.
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 
   // Disconnect first client.
   ExpectClientDisconnected(0);
   client1_->OnConnectionClosed(connection1_, protocol::OK);
 
   // Connect second client.
   ExpectClientConnected(1);
   SimulateClientConnection(1, true, false);
 
   // Disconnect second client.
   ExpectClientDisconnected(1);
   client2_->OnConnectionClosed(connection2_, protocol::OK);
 }
 
 TEST_F(ChromotingHostTest, ConnectWhenAnotherClientIsConnected) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 
   // Connect first client.
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 
   // Connect second client. First client should be disconnected automatically.
   {
     InSequence s;
     ExpectClientDisconnected(0);
     ExpectClientConnected(1);
   }
   SimulateClientConnection(1, true, false);
 
   // Disconnect second client.
   ExpectClientDisconnected(1);
   client2_->OnConnectionClosed(connection2_, protocol::OK);
 }
 
 TEST_F(ChromotingHostTest, IncomingSessionAccepted) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 
   MockSession* session = session_unowned1_.get();
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::DECLINE;
   host_->OnIncomingSession(session_unowned1_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   EXPECT_CALL(*session, Close(_)).WillOnce(InvokeWithoutArgs(
     this, &ChromotingHostTest::NotifyConnectionClosed1));
   ShutdownHost();
 }
 
 TEST_F(ChromotingHostTest, LoginBackOffUponConnection) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::DECLINE;
 
   EXPECT_CALL(*session_unowned1_, Close(_)).WillOnce(
     InvokeWithoutArgs(this, &ChromotingHostTest::NotifyConnectionClosed1));
   host_->OnIncomingSession(session_unowned1_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   host_->OnSessionAuthenticating(get_clients_from_host().front());
   host_->OnIncomingSession(session_unowned2_.get(), &response);
   EXPECT_EQ(protocol::SessionManager::OVERLOAD, response);
 }
 
 TEST_F(ChromotingHostTest, LoginBackOffUponAuthenticating) {
-  ExpectHostAndSessionManagerStart();
+  StartHost();
 
   EXPECT_CALL(*session_unowned1_, Close(_)).WillOnce(
     InvokeWithoutArgs(this, &ChromotingHostTest::NotifyConnectionClosed1));
 
   EXPECT_CALL(*session_unowned2_, Close(_)).WillOnce(
     InvokeWithoutArgs(this, &ChromotingHostTest::NotifyConnectionClosed2));
 
-  host_->Start(xmpp_login_);
-
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::DECLINE;
 
   host_->OnIncomingSession(session_unowned1_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   host_->OnIncomingSession(session_unowned2_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   // This will set the backoff.
   host_->OnSessionAuthenticating(get_clients_from_host().front());
 
   // This should disconnect client2.
   host_->OnSessionAuthenticating(get_clients_from_host().back());
 
   // Verify that the host only has 1 client at this point.
   EXPECT_EQ(get_clients_from_host().size(), 1U);
 }
 
 TEST_F(ChromotingHostTest, OnSessionRouteChange) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 
 
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 
   std::string channel_name("ChannelName");
   protocol::TransportRoute route;
   EXPECT_CALL(host_status_observer_,
               OnClientRouteChange(session_jid1_, channel_name, _));
   host_->OnSessionRouteChange(get_client(0), channel_name, route);
 }
 
 TEST_F(ChromotingHostTest, DisconnectAllClients) {
-  ExpectHostAndSessionManagerStart();
-  host_->Start(xmpp_login_);
+  StartHost();
 
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 
   ExpectClientDisconnected(0);
   DisconnectAllClients();
   testing::Mock::VerifyAndClearExpectations(&host_status_observer_);
 }
 
 }  // namespace remoting