Replace MockConnectionToClient with FakeConnectionToClient

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/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::MockConnectionToClient;
 using ::remoting::protocol::MockConnectionToClientEventHandler;
 using ::remoting::protocol::MockHostStub;
 using ::remoting::protocol::MockSession;
 using ::remoting::protocol::MockVideoStub;
 using ::remoting::protocol::Session;
 using ::remoting::protocol::SessionConfig;
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
@@ skipping 86 matching lines @@
         .WillRepeatedly(SaveArg<0>(&session_unowned1_event_handler_));
     EXPECT_CALL(*session_unowned2_, SetEventHandler(_))
         .Times(AnyNumber())
         .WillRepeatedly(SaveArg<0>(&session_unowned2_event_handler_));
     EXPECT_CALL(*session1_, config())
         .WillRepeatedly(ReturnRef(*session_config1_));
     EXPECT_CALL(*session2_, config())
         .WillRepeatedly(ReturnRef(*session_config2_));
 
     owned_connection1_.reset(
-        new MockConnectionToClient(make_scoped_ptr(session1_), &host_stub1_));
+        new protocol::FakeConnectionToClient(make_scoped_ptr(session1_)));
+    owned_connection1_->set_host_stub(&host_stub1_);
     connection1_ = owned_connection1_.get();
+    connection1_->set_video_stub(&video_stub1_);
+    connection1_->set_client_stub(&client_stub1_);
+
     owned_connection2_.reset(
-        new MockConnectionToClient(make_scoped_ptr(session2_), &host_stub2_));
+        new protocol::FakeConnectionToClient(make_scoped_ptr(session2_)));
+    owned_connection2_->set_host_stub(&host_stub2_);
     connection2_ = owned_connection2_.get();
+    connection2_->set_video_stub(&video_stub2_);
+    connection2_->set_client_stub(&client_stub2_);
 
     ON_CALL(video_stub1_, ProcessVideoPacketPtr(_, _))
         .WillByDefault(DeleteArg<0>());
     ON_CALL(video_stub2_, ProcessVideoPacketPtr(_, _))
         .WillByDefault(DeleteArg<0>());
-    ON_CALL(*connection1_, video_stub())
-        .WillByDefault(Return(&video_stub1_));
-    ON_CALL(*connection1_, client_stub())
-        .WillByDefault(Return(&client_stub1_));
-    ON_CALL(*connection2_, video_stub())
-        .WillByDefault(Return(&video_stub2_));
-    ON_CALL(*connection2_, client_stub())
-        .WillByDefault(Return(&client_stub2_));
-    EXPECT_CALL(*connection1_, video_stub())
-        .Times(AnyNumber());
-    EXPECT_CALL(*connection1_, client_stub())
-        .Times(AnyNumber());
-    EXPECT_CALL(*connection2_, video_stub())
-        .Times(AnyNumber());
-    EXPECT_CALL(*connection2_, client_stub())
-        .Times(AnyNumber());
   }
 
   // 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_)
             .Pass();
     protocol::ConnectionToClient* connection_ptr = connection.get();
     scoped_ptr<ClientSession> client(new ClientSession(
@@ skipping 163 matching lines @@
             action,
             RunDoneTask()))
         .RetiresOnSaturation();
     EXPECT_CALL(video_stub, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber())
         .After(video_packet_sent)
         .WillRepeatedly(RunDoneTask());
     return video_packet_sent;
   }
 
-  // Return an expectation that a client will disconnect after a given
-  // expectation. The given action will be done after the event executor is
-  // notified that the session has finished.
+  // Expect that a client is disconnected after a given expectation. The given
+  // action will be done after the status observer is notified that the session
+  // has finished.
   template <class A>
   Expectation ExpectClientDisconnected(int connection_index,
-                                       bool expect_host_status_change,
                                        Expectation after,
                                        A action) {
-    MockConnectionToClient* connection = get_connection(connection_index);
-
-    Expectation client_disconnected =
-        EXPECT_CALL(*connection, Disconnect(_))
-            .After(after)
-            .WillOnce(InvokeWithoutArgs(CreateFunctor(
-                this, &ChromotingHostTest::NotifyClientSessionClosed,
-                connection_index)))
-            .RetiresOnSaturation();
-    ExpectClientDisconnectEffects(connection_index,
-                                  expect_host_status_change,
-                                  after,
-                                  action);
-    return client_disconnected;
-  }
-
-  // Expect the side-effects of a client disconnection, after a given
-  // expectation. The given action will be done after the event executor is
-  // notifed that the session has finished.
-  template <class A>
-  void ExpectClientDisconnectEffects(int connection_index,
-                                     bool expect_host_status_change,
-                                     Expectation after,
-                                     A action) {
-    const std::string& session_jid = get_session_jid(connection_index);
-
-    if (expect_host_status_change) {
-      EXPECT_CALL(host_status_observer_, OnClientDisconnected(session_jid))
-          .After(after)
-          .WillOnce(action)
-          .RetiresOnSaturation();
-    }
+    return EXPECT_CALL(host_status_observer_,
+                       OnClientDisconnected(get_session_jid(connection_index)))
+        .After(after)
+        .WillOnce(action)
+        .RetiresOnSaturation();
   }
 
  protected:
   base::MessageLoop message_loop_;
   scoped_refptr<AutoThreadTaskRunner> task_runner_;
   MockConnectionToClientEventHandler handler_;
   MockSignalStrategy signal_strategy_;
   scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
   scoped_ptr<ChromotingHost> host_;
   MockHostStatusObserver host_status_observer_;
   protocol::MockSessionManager* session_manager_;
   std::string xmpp_login_;
-  MockConnectionToClient* connection1_;
-  scoped_ptr<MockConnectionToClient> owned_connection1_;
+  protocol::FakeConnectionToClient* connection1_;
+  scoped_ptr<protocol::FakeConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
   MockSession* session1_;  // Owned by |connection_|.
   scoped_ptr<SessionConfig> session_config1_;
   MockVideoStub video_stub1_;
   MockClientStub client_stub1_;
   MockHostStub host_stub1_;
-  MockConnectionToClient* connection2_;
-  scoped_ptr<MockConnectionToClient> owned_connection2_;
+  protocol::FakeConnectionToClient* connection2_;
+  scoped_ptr<protocol::FakeConnectionToClient> owned_connection2_;
   ClientSession* client2_;
   std::string session_jid2_;
   MockSession* session2_;  // Owned by |connection2_|.
   scoped_ptr<SessionConfig> session_config2_;
   MockVideoStub video_stub2_;
   MockClientStub client_stub2_;
   MockHostStub host_stub2_;
   scoped_ptr<MockSession> session_unowned1_;  // Not owned by a connection.
   std::string session_unowned_jid1_;
   scoped_ptr<MockSession> session_unowned2_;  // Not owned by a connection.
   std::string session_unowned_jid2_;
   protocol::Session::EventHandler* session_unowned1_event_handler_;
   protocol::Session::EventHandler* session_unowned2_event_handler_;
 
-  MockConnectionToClient*& get_connection(int connection_index) {
+  protocol::FakeConnectionToClient*& get_connection(int connection_index) {
     return (connection_index == 0) ? connection1_ : connection2_;
   }
 
   // Returns the cached client pointers client1_ or client2_.
   ClientSession*& get_client(int connection_index) {
     return (connection_index == 0) ? client1_ : client2_;
   }
 
   // Returns the list of clients of the host_.
   std::list<ClientSession*>& get_clients_from_host() {
@@ skipping 17 matching lines @@
   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(base::DoNothing));
-  EXPECT_CALL(host_status_observer_, OnShutdown()).After(client_disconnected);
+  EXPECT_CALL(host_status_observer_, OnShutdown()).After(video_packet_sent);
 
   host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   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(base::DoNothing));
+  ExpectClientDisconnected(
+      0, video_packet_sent1, InvokeWithoutArgs(base::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(base::DoNothing));
+      1, video_packet_sent2, InvokeWithoutArgs(base::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(base::DoNothing));
+      0, video_packet_sent1, InvokeWithoutArgs(base::DoNothing));
   Expectation video_packet_sent2 = ExpectClientConnected(
       1, InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   Expectation client_disconnected2 = ExpectClientDisconnected(
-      1, true, video_packet_sent2, InvokeWithoutArgs(base::DoNothing));
+      1, video_packet_sent2, InvokeWithoutArgs(base::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) {
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::ACCEPT;
@@ skipping 78 matching lines @@
   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(
+      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(base::DoNothing));
+      EXPECT_CALL(host_status_observer_,
+                  OnClientRouteChange(session_jid1_, channel_name, _))
+          .After(video_packet_sent)
+          .WillOnce(InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
+  ExpectClientDisconnected(0, route_change, InvokeWithoutArgs(base::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,
+  ExpectClientDisconnected(
+      0, 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