Log when the host is started for an account.

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/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "remoting/jingle_glue/mock_objects.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_host_context.h"
@@ skipping 91 matching lines @@
     continue_window_ = new MockContinueWindow();
     local_input_monitor_ = new MockLocalInputMonitor();
     it2me_host_user_interface_.reset(new It2MeHostUserInterface(&context_));
     it2me_host_user_interface_->StartForTest(
         host_,
         base::Bind(&ChromotingHost::Shutdown, host_, base::Closure()),
         scoped_ptr<DisconnectWindow>(disconnect_window_),
         scoped_ptr<ContinueWindow>(continue_window_),
         scoped_ptr<LocalInputMonitor>(local_input_monitor_));
 
+    xmpp_login_ = "host@domain";
     session1_ = new MockSession();
     session2_ = new MockSession();
     session_unowned1_.reset(new MockSession());
     session_unowned2_.reset(new MockSession());
     session_config1_ = SessionConfig::GetDefault();
     session_jid1_ = "user@domain/rest-of-jid";
     session_config2_ = SessionConfig::GetDefault();
     session_jid2_ = "user2@domain/rest-of-jid";
     session_unowned_config1_ = SessionConfig::GetDefault();
     session_unowned_jid1_ = "user3@doman/rest-of-jid";
@@ skipping 157 matching lines @@
   // Expect the host to start.
   void ExpectHostStart() {
     EXPECT_CALL(*disconnect_window_, Hide());
     EXPECT_CALL(*continue_window_, Hide());
   }
 
   // Expect the host and session manager to start, and return the expectation
   // that the session manager has started.
   Expectation ExpectHostAndSessionManagerStart() {
     ExpectHostStart();
+    EXPECT_CALL(host_status_observer_, OnStart(xmpp_login_));
     return EXPECT_CALL(*session_manager_, Init(_, host_.get()));
   }
 
   // Expect a client to connect.
   // Return an expectation that a session has started, and that the first
   // video packet has been sent to the client.
   // Do |action| when that happens.
   template <class A>
   Expectation ExpectClientConnected(int connection_index, A action) {
     const std::string& session_jid = get_session_jid(connection_index);
@@ skipping 69 matching lines @@
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   MockConnectionToClientEventHandler handler_;
   MockSignalStrategy signal_strategy_;
   MockEventExecutor* event_executor_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
   scoped_ptr<It2MeHostUserInterface> it2me_host_user_interface_;
   scoped_refptr<ChromotingHost> host_;
   MockHostStatusObserver host_status_observer_;
   MockChromotingHostContext context_;
   protocol::MockSessionManager* session_manager_;
+  std::string xmpp_login_;
   MockConnectionToClient* connection1_;
   scoped_ptr<MockConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
   MockSession* session1_;  // Owned by |connection_|.
   SessionConfig session_config1_;
   MockVideoStub video_stub1_;
   MockClientStub client_stub1_;
   MockHostStub host_stub1_;
   MockConnectionToClient* connection2_;
@@ skipping 34 matching lines @@
 
   MockVideoStub& get_video_stub(int connection_index) {
     return (connection_index == 0) ? video_stub1_ : video_stub2_;
   }
 };
 
 TEST_F(ChromotingHostTest, StartAndShutdown) {
   Expectation start = ExpectHostAndSessionManagerStart();
   EXPECT_CALL(host_status_observer_, OnShutdown()).After(start);
 
-  host_->Start();
+  host_->Start(xmpp_login_);
   message_loop_.PostTask(
       FROM_HERE, base::Bind(
           &ChromotingHost::Shutdown, host_.get(),
           base::Bind(&PostQuitTask, &message_loop_)));
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, Connect) {
   ExpectHostAndSessionManagerStart();
 
   // Shut down the host when the first video packet is received.
   Expectation video_packet_sent = ExpectClientConnected(
       0, InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   Expectation client_disconnected = ExpectClientDisconnected(
       0, true, video_packet_sent, InvokeWithoutArgs(DoNothing));
   EXPECT_CALL(host_status_observer_, OnShutdown()).After(client_disconnected);
 
-  host_->Start();
+  host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, RejectAuthenticatingClient) {
   Expectation start = ExpectHostAndSessionManagerStart();
   EXPECT_CALL(host_status_observer_, OnClientAuthenticated(session_jid1_))
       .WillOnce(InvokeWithoutArgs(
       this, &ChromotingHostTest::RejectAuthenticatingClient));
   ExpectClientDisconnected(
       0, true, start,
       InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
-  host_->Start();
+  host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, true);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, AuthenticationFailed) {
   ExpectHostAndSessionManagerStart();
   EXPECT_CALL(host_status_observer_, OnAccessDenied(session_jid1_))
       .WillOnce(InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
-  host_->Start();
+  host_->Start(xmpp_login_);
   SimulateClientConnection(0, false, false);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, Reconnect) {
   ExpectHostAndSessionManagerStart();
 
   // When a video packet is received on the first connection, disconnect it,
   // then quit the message loop.
   Expectation video_packet_sent1 = ExpectClientConnected(0, DoAll(
       InvokeWithoutArgs(this, &ChromotingHostTest::DisconnectClient1),
       InvokeWithoutArgs(this, &ChromotingHostTest::QuitMainMessageLoop)));
   ExpectClientDisconnectEffects(
       0, true, video_packet_sent1, InvokeWithoutArgs(DoNothing));
 
   // When a video packet is received on the second connection, shut down the
   // host.
   Expectation video_packet_sent2 = ExpectClientConnected(
       1, InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   Expectation client_disconnected2 = ExpectClientDisconnected(
       1, true, video_packet_sent2, InvokeWithoutArgs(DoNothing));
   EXPECT_CALL(host_status_observer_, OnShutdown()).After(client_disconnected2);
 
-  host_->Start();
+  host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
   SimulateClientConnection(1, true, false);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, ConnectWhenAnotherClientIsConnected) {
   ExpectHostAndSessionManagerStart();
 
   // When a video packet is received, connect the second connection.
   // This should disconnect the first connection.
   Expectation video_packet_sent1 = ExpectClientConnected(
       0,
       InvokeWithoutArgs(
           CreateFunctor(
               this,
               &ChromotingHostTest::SimulateClientConnection, 1, true, false)));
   ExpectClientDisconnected(
       0, true, video_packet_sent1, InvokeWithoutArgs(DoNothing));
   Expectation video_packet_sent2 = ExpectClientConnected(
       1, InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   Expectation client_disconnected2 = ExpectClientDisconnected(
       1, true, video_packet_sent2, InvokeWithoutArgs(DoNothing));
   EXPECT_CALL(host_status_observer_, OnShutdown()).After(client_disconnected2);
 
-  host_->Start();
+  host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, IncomingSessionDeclined) {
   ExpectHostStart();
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::ACCEPT;
   host_->OnIncomingSession(session1_, &response);
   EXPECT_EQ(protocol::SessionManager::DECLINE, response);
 }
 
 TEST_F(ChromotingHostTest, IncomingSessionIncompatible) {
   ExpectHostAndSessionManagerStart();
   EXPECT_CALL(*session_unowned1_, candidate_config()).WillOnce(Return(
       empty_candidate_config_.get()));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
   host_->set_protocol_config(
       protocol::CandidateSessionConfig::CreateDefault().release());
-  host_->Start();
+  host_->Start(xmpp_login_);
 
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::ACCEPT;
   host_->OnIncomingSession(session_unowned1_.get(), &response);
   EXPECT_EQ(protocol::SessionManager::INCOMPATIBLE, response);
 
   host_->Shutdown(base::Bind(&DoNothing));
 }
 
 TEST_F(ChromotingHostTest, IncomingSessionAccepted) {
   ExpectHostAndSessionManagerStart();
   EXPECT_CALL(*session_unowned1_, candidate_config()).WillOnce(Return(
       default_candidate_config_.get()));
   EXPECT_CALL(*session_unowned1_, set_config(_));
   EXPECT_CALL(*session_unowned1_, Close()).WillOnce(InvokeWithoutArgs(
       this, &ChromotingHostTest::NotifyConnectionClosed));
   EXPECT_CALL(host_status_observer_, OnAccessDenied(_));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
   host_->set_protocol_config(
       protocol::CandidateSessionConfig::CreateDefault().release());
-  host_->Start();
+  host_->Start(xmpp_login_);
 
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::DECLINE;
   host_->OnIncomingSession(session_unowned1_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   host_->Shutdown(base::Bind(&DoNothing));
 }
 
 TEST_F(ChromotingHostTest, IncomingSessionOverload) {
   ExpectHostAndSessionManagerStart();
   EXPECT_CALL(*session_unowned1_, candidate_config()).WillOnce(Return(
       default_candidate_config_.get()));
   EXPECT_CALL(*session_unowned1_, set_config(_));
   EXPECT_CALL(*session_unowned1_, Close()).WillOnce(InvokeWithoutArgs(
       this, &ChromotingHostTest::NotifyConnectionClosed));
   EXPECT_CALL(host_status_observer_, OnAccessDenied(_));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
   host_->set_protocol_config(
       protocol::CandidateSessionConfig::CreateDefault().release());
-  host_->Start();
+  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_.get(), &response);
   EXPECT_EQ(protocol::SessionManager::OVERLOAD, response);
 
   host_->Shutdown(base::Bind(&DoNothing));
 }
 
 TEST_F(ChromotingHostTest, OnSessionRouteChange) {
   std::string channel_name("ChannelName");
   protocol::TransportRoute route;
 
   ExpectHostAndSessionManagerStart();
   Expectation video_packet_sent = ExpectClientConnected(
       0, InvokeWithoutArgs(CreateFunctor(
           this, &ChromotingHostTest::ChangeSessionRoute, channel_name, route)));
   Expectation route_change =
       EXPECT_CALL(host_status_observer_, OnClientRouteChange(
           session_jid1_, channel_name, _))
       .After(video_packet_sent)
       .WillOnce(InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   ExpectClientDisconnected(0, true, route_change, InvokeWithoutArgs(DoNothing));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
-  host_->Start();
+  host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, DisconnectAllClients) {
   ExpectHostAndSessionManagerStart();
   Expectation video_packet_sent = ExpectClientConnected(
       0, InvokeWithoutArgs(this, &ChromotingHostTest::DisconnectAllClients));
   ExpectClientDisconnected(0, true, video_packet_sent,
       InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
-  host_->Start();
+  host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 }  // namespace remoting