Cleanup ChannelMultiplexer tests to avoid dependency on FakeSession.

remoting/protocol/channel_multiplexer_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 "remoting/protocol/channel_multiplexer.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/connection_tester.h"
-#include "remoting/protocol/fake_session.h"
+#include "remoting/protocol/fake_stream_socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtMost;
 using testing::InvokeWithoutArgs;
 
 namespace remoting {
 namespace protocol {
 
@@ skipping 38 matching lines @@
     client_mux_.reset();
   }
 
   void DeleteAfterSessionFail() {
     host_mux_->CancelChannelCreation(kTestChannelName2);
     DeleteAll();
   }
 
  protected:
   void SetUp() override {
+    host_channel_factory_.PairWith(&client_channel_factory_);
+
     // Create pair of multiplexers and connect them to each other.
-    host_mux_.reset(new ChannelMultiplexer(
-        host_session_.GetTransport()->GetStreamChannelFactory(),
-        kMuxChannelName));
-    client_mux_.reset(new ChannelMultiplexer(
-        client_session_.GetTransport()->GetStreamChannelFactory(),
-        kMuxChannelName));
-  }
+    host_mux_.reset(
+        new ChannelMultiplexer(&host_channel_factory_, kMuxChannelName));
+    client_mux_.reset(
+        new ChannelMultiplexer(&client_channel_factory_, kMuxChannelName));
 
-  // Connect sockets to each other. Must be called after we've created at least
-  // one channel with each multiplexer.
-  void ConnectSockets() {
-    FakeStreamSocket* host_socket =
-        host_session_.GetTransport()
-            ->GetStreamChannelFactory()
-            ->GetFakeChannel(ChannelMultiplexer::kMuxChannelName);
-    FakeStreamSocket* client_socket =
-        client_session_.GetTransport()
-            ->GetStreamChannelFactory()
-            ->GetFakeChannel(ChannelMultiplexer::kMuxChannelName);
-    host_socket->PairWith(client_socket);
-
-    // Make writes asynchronous in one direction.
-    host_socket->set_async_write(true);
+    // Make writes asynchronous in one direction
+    host_channel_factory_.set_async_write(true);
   }
 
   void CreateChannel(const std::string& name,
                      scoped_ptr<P2PStreamSocket>* host_socket,
                      scoped_ptr<P2PStreamSocket>* client_socket) {
     int counter = 2;
     host_mux_->CreateChannel(name, base::Bind(
         &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this),
         host_socket, &counter));
     client_mux_->CreateChannel(name, base::Bind(
@@ skipping 21 matching lines @@
     scoped_refptr<net::IOBufferWithSize> result =
         new net::IOBufferWithSize(size);
     for (int i = 0; i< size; ++i) {
       result->data()[i] = rand() % 256;
     }
     return result;
   }
 
   base::MessageLoop message_loop_;
 
-  FakeSession host_session_;
-  FakeSession client_session_;
+  FakeStreamChannelFactory host_channel_factory_;
+  FakeStreamChannelFactory client_channel_factory_;
 
   scoped_ptr<ChannelMultiplexer> host_mux_;
   scoped_ptr<ChannelMultiplexer> client_mux_;
 
   scoped_ptr<P2PStreamSocket> host_socket1_;
   scoped_ptr<P2PStreamSocket> client_socket1_;
   scoped_ptr<P2PStreamSocket> host_socket2_;
   scoped_ptr<P2PStreamSocket> client_socket2_;
 };
 
 
 TEST_F(ChannelMultiplexerTest, OneChannel) {
   scoped_ptr<P2PStreamSocket> host_socket;
   scoped_ptr<P2PStreamSocket> client_socket;
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName, &host_socket, &client_socket));
 
-  ConnectSockets();
-
   StreamConnectionTester tester(host_socket.get(), client_socket.get(),
                                 kMessageSize, kMessages);
   tester.Start();
   message_loop_.Run();
   tester.CheckResults();
 }
 
 TEST_F(ChannelMultiplexerTest, TwoChannels) {
   scoped_ptr<P2PStreamSocket> host_socket1_;
   scoped_ptr<P2PStreamSocket> client_socket1_;
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 
   scoped_ptr<P2PStreamSocket> host_socket2_;
   scoped_ptr<P2PStreamSocket> client_socket2_;
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 
-  ConnectSockets();
-
   StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(),
                                 kMessageSize, kMessages);
   StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(),
                                  kMessageSize, kMessages);
   tester1.Start();
   tester2.Start();
   while (!tester1.done() || !tester2.done()) {
     message_loop_.Run();
   }
   tester1.CheckResults();
@@ skipping 15 matching lines @@
   scoped_ptr<P2PStreamSocket> host_socket3;
   scoped_ptr<P2PStreamSocket> client_socket3;
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel("test3", &host_socket3, &client_socket3));
 
   scoped_ptr<P2PStreamSocket> host_socket4;
   scoped_ptr<P2PStreamSocket> client_socket4;
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel("ch4", &host_socket4, &client_socket4));
 
-  ConnectSockets();
-
   StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(),
                                 kMessageSize, kMessages);
   StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(),
                                  kMessageSize, kMessages);
   StreamConnectionTester tester3(client_socket3.get(), host_socket3.get(),
                                  kMessageSize, kMessages);
   StreamConnectionTester tester4(client_socket4.get(), host_socket4.get(),
                                  kMessageSize, kMessages);
   tester1.Start();
   tester2.Start();
@@ skipping 13 matching lines @@
   scoped_ptr<P2PStreamSocket> host_socket1_;
   scoped_ptr<P2PStreamSocket> client_socket1_;
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 
   scoped_ptr<P2PStreamSocket> host_socket2_;
   scoped_ptr<P2PStreamSocket> client_socket2_;
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 
-  ConnectSockets();
-
   FakeStreamSocket* socket =
-      host_session_.GetTransport()->GetStreamChannelFactory()->GetFakeChannel(
-          kMuxChannelName);
+      host_channel_factory_.GetFakeChannel(kMuxChannelName);
   socket->set_next_write_error(net::ERR_FAILED);
   socket->set_async_write(false);
 
   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 
   MockSocketCallback cb1;
   MockSocketCallback cb2;
   EXPECT_CALL(cb1, OnDone(net::ERR_FAILED));
   EXPECT_CALL(cb2, OnDone(net::ERR_FAILED));
 
@@ skipping 11 matching lines @@
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ChannelMultiplexerTest, WriteFailAsync) {
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 
-  ConnectSockets();
-
   FakeStreamSocket* socket =
-      host_session_.GetTransport()->GetStreamChannelFactory()->GetFakeChannel(
-          kMuxChannelName);
+      host_channel_factory_.GetFakeChannel(kMuxChannelName);
   socket->set_next_write_error(net::ERR_FAILED);
   socket->set_async_write(true);
 
   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 
   MockSocketCallback cb1;
   MockSocketCallback cb2;
   EXPECT_CALL(cb1, OnDone(net::ERR_FAILED));
   EXPECT_CALL(cb2, OnDone(net::ERR_FAILED));
 
@@ skipping 10 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ChannelMultiplexerTest, DeleteWhenFailed) {
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 
-  ConnectSockets();
-
   FakeStreamSocket* socket =
-      host_session_.GetTransport()->GetStreamChannelFactory()->GetFakeChannel(
-          kMuxChannelName);
+      host_channel_factory_.GetFakeChannel(kMuxChannelName);
   socket->set_next_write_error(net::ERR_FAILED);
   socket->set_async_write(true);
 
   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 
   MockSocketCallback cb1;
   MockSocketCallback cb2;
 
   EXPECT_CALL(cb1, OnDone(net::ERR_FAILED))
       .Times(AtMost(1))
@@ skipping 13 matching lines @@
                                  base::Bind(&MockSocketCallback::OnDone,
                                             base::Unretained(&cb2))));
 
   base::RunLoop().RunUntilIdle();
 
   // Check that the sockets were destroyed.
   EXPECT_FALSE(host_mux_.get());
 }
 
 TEST_F(ChannelMultiplexerTest, SessionFail) {
-  host_session_.GetTransport()->GetStreamChannelFactory()
-      ->set_asynchronous_create(true);
-  host_session_.GetTransport()->GetStreamChannelFactory()
-      ->set_fail_create(true);
+  host_channel_factory_.set_asynchronous_create(true);
+  host_channel_factory_.set_fail_create(true);
 
   MockConnectCallback cb1;
   MockConnectCallback cb2;
 
   host_mux_->CreateChannel(kTestChannelName, base::Bind(
       &MockConnectCallback::OnConnected, base::Unretained(&cb1)));
   host_mux_->CreateChannel(kTestChannelName2, base::Bind(
       &MockConnectCallback::OnConnected, base::Unretained(&cb2)));
 
   EXPECT_CALL(cb1, OnConnectedPtr(nullptr))
       .Times(AtMost(1))
       .WillOnce(InvokeWithoutArgs(
           this, &ChannelMultiplexerTest::DeleteAfterSessionFail));
   EXPECT_CALL(cb2, OnConnectedPtr(_))
       .Times(0);
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace protocol
 }  // namespace remoting