[remoting_unittests] Moving the variable used to mock VideoFrameCapturer::size_most_recent() to the…

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/base/auto_thread_task_runner.h"
 #include "remoting/jingle_glue/mock_objects.h"
 #include "remoting/host/audio_capturer.h"
@@ skipping 197 matching lines @@
         .Times(AnyNumber());
     EXPECT_CALL(*connection2_, session())
         .Times(AnyNumber());
 
     empty_candidate_config_ =
         protocol::CandidateSessionConfig::CreateEmpty();
     default_candidate_config_ =
         protocol::CandidateSessionConfig::CreateDefault();
   }
 
+  virtual void TearDown() OVERRIDE {
+    // Run the message loop to finish outstanding tasks.
+    message_loop_.Run();

[simonmorris, 2012/09/13 16:51:40]

I'm not convinced the benefits of this exceed the costs.

It's surprising to have the main loop, where (for almost all tests) all the work
is actually done, occur in a method called TearDown.

And it makes Reconnect() harder to understand. "Why is there a
message_loop.Run() after the first SimulateClientConnection(), but not the
second? Oh, I see: the other message_loop.Run() is in a method where I don't
expect it, 300 lines anyway."

[alexeypa (please no reviews), 2012/09/13 18:06:17]

Done.

+  }
+
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate,
                                 bool reject) {
     scoped_ptr<protocol::ConnectionToClient> connection =
         ((connection_index == 0) ? owned_connection1_ : owned_connection2_).
         PassAs<protocol::ConnectionToClient>();
     protocol::ConnectionToClient* connection_ptr = connection.get();
     scoped_ptr<DesktopEnvironment> desktop_environment =
         host_->desktop_environment_factory_->Create(&context_);
     connection_ptr->set_input_stub(desktop_environment->event_executor());
@@ skipping 235 matching lines @@
     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(xmpp_login_);
   ShutdownHost();
-  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(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(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(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(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(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);
 
   ShutdownHost();
-  message_loop_.Run();
 }
 
 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(xmpp_login_);
 
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::ACCEPT;
   host_->OnIncomingSession(session_unowned1_.get(), &response);
   EXPECT_EQ(protocol::SessionManager::INCOMPATIBLE, response);
 
   ShutdownHost();
-  message_loop_.Run();
 }
 
 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(xmpp_login_);
 
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::DECLINE;
   host_->OnIncomingSession(session_unowned1_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   ShutdownHost();
-  message_loop_.Run();
 }
 
 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(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);
 
   ShutdownHost();
-  message_loop_.Run();
 }
 
 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(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(xmpp_login_);
   SimulateClientConnection(0, true, false);
-  message_loop_.Run();
 }
 
 }  // namespace remoting