Replace MockConnectionToClient with FakeConnectionToClient

remoting/host/client_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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/test/test_simple_task_runner.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/fake_host_extension.h"
 #include "remoting/host/fake_mouse_cursor_monitor.h"
 #include "remoting/host/host_extension.h"
 #include "remoting/host/host_extension_session.h"
 #include "remoting/host/host_mock_objects.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/test_event_matchers.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer_mock_objects.h"
 
 namespace remoting {
 
 using protocol::MockClientStub;
-using protocol::MockConnectionToClient;
 using protocol::MockHostStub;
 using protocol::MockInputStub;
 using protocol::MockSession;
 using protocol::MockVideoStub;
 using protocol::SessionConfig;
 using protocol::test::EqualsClipboardEvent;
 using protocol::test::EqualsMouseButtonEvent;
 using protocol::test::EqualsMouseMoveEvent;
 using protocol::test::EqualsKeyEvent;
 
@@ skipping 138 matching lines @@
 
   // Stubs returned to |client_session_| components by |connection_|.
   MockClientStub client_stub_;
   MockVideoStub video_stub_;
 
   // DesktopEnvironment owns |input_injector_|, but input injection tests need
   // to express expectations on it.
   scoped_ptr<MockInputInjector> input_injector_;
 
   // ClientSession owns |connection_| but tests need it to inject fake events.
-  MockConnectionToClient* connection_;
+  protocol::FakeConnectionToClient* connection_;
 
   scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
 };
 
 void ClientSessionTest::SetUp() {
   // Arrange to run |message_loop_| until no components depend on it.
   task_runner_ = new AutoThreadTaskRunner(
       message_loop_.task_runner(), run_loop_.QuitClosure());
 
   desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
@@ skipping 18 matching lines @@
 }
 
 void ClientSessionTest::CreateClientSession() {
   // Mock protocol::Session APIs called directly by ClientSession.
   scoped_ptr<protocol::MockSession> session(new MockSession());
   EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(*session_config_));
   EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
 
   // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
   // HostStub is not touched by ClientSession, so we can safely pass nullptr.
-  scoped_ptr<MockConnectionToClient> connection(
-      new MockConnectionToClient(session.Pass(), nullptr));
-  EXPECT_CALL(*connection, client_stub())
-      .WillRepeatedly(Return(&client_stub_));
-  EXPECT_CALL(*connection, video_stub()).WillRepeatedly(Return(&video_stub_));
-  EXPECT_CALL(*connection, Disconnect(_));
+  scoped_ptr<protocol::FakeConnectionToClient> connection(
+      new protocol::FakeConnectionToClient(session.Pass()));
+  connection->set_client_stub(&client_stub_);
+  connection->set_video_stub(&video_stub_);
   connection_ = connection.get();
 
   client_session_.reset(new ClientSession(
       &session_event_handler_,
       task_runner_,  // Audio thread.
       task_runner_,  // Input thread.
       task_runner_,  // Capture thread.
       task_runner_,  // Encode thread.
       task_runner_,  // Network thread.
       task_runner_,  // UI thread.
       connection.Pass(),
       desktop_environment_factory_.get(),
       base::TimeDelta(),
       nullptr,
       extensions_));
 }
 
 void ClientSessionTest::DisconnectClientSession() {
   client_session_->DisconnectSession(protocol::OK);
-  // MockSession won't trigger OnConnectionClosed, so fake it.
-  client_session_->OnConnectionClosed(client_session_->connection(),
-                                      protocol::OK);
 }
 
 void ClientSessionTest::StopClientSession() {
   client_session_.reset();
 
   desktop_environment_factory_.reset();
 }
 
 DesktopEnvironment* ClientSessionTest::CreateDesktopEnvironment() {
   MockDesktopEnvironment* desktop_environment = new MockDesktopEnvironment();
@@ skipping 485 matching lines @@
 
   DisconnectClientSession();
   StopClientSession();
 
   // ext1 was instantiated and wrapped the video capturer.
   EXPECT_TRUE(extension.was_instantiated());
   EXPECT_TRUE(extension.has_wrapped_video_capturer());
 }
 
 }  // namespace remoting