remoting/protocol/channel_multiplexer_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/protocol/channel_multiplexer.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "net/base/net_errors.h"
  10 #include "net/socket/socket.h"
  11 #include "net/socket/stream_socket.h"
  12 #include "remoting/base/constants.h"
  13 #include "remoting/protocol/connection_tester.h"
  14 #include "remoting/protocol/fake_session.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using testing::_;
  19 using testing::AtMost;
  20 using testing::InvokeWithoutArgs;
  21
  22 namespace remoting {
  23 namespace protocol {
  24
  25 namespace {
  26
  27 const int kMessageSize = 1024;
  28 const int kMessages = 100;
  29 const char kMuxChannelName[] = "mux";
  30
  31 const char kTestChannelName[] = "test";
  32 const char kTestChannelName2[] = "test2";
  33
  34
  35 void QuitCurrentThread() {
  36   base::MessageLoop::current()->PostTask(FROM_HERE,
  37                                          base::MessageLoop::QuitClosure());
  38 }
  39
  40 class MockSocketCallback {
  41  public:
  42   MOCK_METHOD1(OnDone, void(int result));
  43 };
  44
  45 class MockConnectCallback {
  46  public:
  47   MOCK_METHOD1(OnConnectedPtr, void(net::StreamSocket* socket));
  48   void OnConnected(scoped_ptr<net::StreamSocket> socket) {
  49     OnConnectedPtr(socket.release());
  50   }
  51 };
  52
  53 }  // namespace
  54
  55 class ChannelMultiplexerTest : public testing::Test {
  56  public:
  57   void DeleteAll() {
  58     host_socket1_.reset();
  59     host_socket2_.reset();
  60     client_socket1_.reset();
  61     client_socket2_.reset();
  62     host_mux_.reset();
  63     client_mux_.reset();
  64   }
  65
  66   void DeleteAfterSessionFail() {
  67     host_mux_->CancelChannelCreation(kTestChannelName2);
  68     DeleteAll();
  69   }
  70
  71  protected:
  72   virtual void SetUp() OVERRIDE {
  73     // Create pair of multiplexers and connect them to each other.
  74     host_mux_.reset(new ChannelMultiplexer(&host_session_, kMuxChannelName));
  75     client_mux_.reset(new ChannelMultiplexer(&client_session_,
  76                                              kMuxChannelName));
  77   }
  78
  79   // Connect sockets to each other. Must be called after we've created at least
  80   // one channel with each multiplexer.
  81   void ConnectSockets() {
  82     FakeSocket* host_socket =
  83         host_session_.GetStreamChannel(ChannelMultiplexer::kMuxChannelName);
  84     FakeSocket* client_socket =
  85         client_session_.GetStreamChannel(ChannelMultiplexer::kMuxChannelName);
  86     host_socket->PairWith(client_socket);
  87
  88     // Make writes asynchronous in one direction.
  89     host_socket->set_async_write(true);
  90   }
  91
  92   void CreateChannel(const std::string& name,
  93                      scoped_ptr<net::StreamSocket>* host_socket,
  94                      scoped_ptr<net::StreamSocket>* client_socket) {
  95     int counter = 2;
  96     host_mux_->CreateStreamChannel(name, base::Bind(
  97         &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this),
  98         host_socket, &counter));
  99     client_mux_->CreateStreamChannel(name, base::Bind(
 100         &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this),
 101         client_socket, &counter));
 102
 103     message_loop_.Run();
 104
 105     EXPECT_TRUE(host_socket->get());
 106     EXPECT_TRUE(client_socket->get());
 107   }
 108
 109   void OnChannelConnected(
 110       scoped_ptr<net::StreamSocket>* storage,
 111       int* counter,
 112       scoped_ptr<net::StreamSocket> socket) {
 113     *storage = socket.Pass();
 114     --(*counter);
 115     EXPECT_GE(*counter, 0);
 116     if (*counter == 0)
 117       QuitCurrentThread();
 118   }
 119
 120   scoped_refptr<net::IOBufferWithSize> CreateTestBuffer(int size) {
 121     scoped_refptr<net::IOBufferWithSize> result =
 122         new net::IOBufferWithSize(size);
 123     for (int i = 0; i< size; ++i) {
 124       result->data()[i] = rand() % 256;
 125     }
 126     return result;
 127   }
 128
 129   base::MessageLoop message_loop_;
 130
 131   FakeSession host_session_;
 132   FakeSession client_session_;
 133
 134   scoped_ptr<ChannelMultiplexer> host_mux_;
 135   scoped_ptr<ChannelMultiplexer> client_mux_;
 136
 137   scoped_ptr<net::StreamSocket> host_socket1_;
 138   scoped_ptr<net::StreamSocket> client_socket1_;
 139   scoped_ptr<net::StreamSocket> host_socket2_;
 140   scoped_ptr<net::StreamSocket> client_socket2_;
 141 };
 142
 143
 144 TEST_F(ChannelMultiplexerTest, OneChannel) {
 145   scoped_ptr<net::StreamSocket> host_socket;
 146   scoped_ptr<net::StreamSocket> client_socket;
 147   ASSERT_NO_FATAL_FAILURE(
 148       CreateChannel(kTestChannelName, &host_socket, &client_socket));
 149
 150   ConnectSockets();
 151
 152   StreamConnectionTester tester(host_socket.get(), client_socket.get(),
 153                                 kMessageSize, kMessages);
 154   tester.Start();
 155   message_loop_.Run();
 156   tester.CheckResults();
 157 }
 158
 159 TEST_F(ChannelMultiplexerTest, TwoChannels) {
 160   scoped_ptr<net::StreamSocket> host_socket1_;
 161   scoped_ptr<net::StreamSocket> client_socket1_;
 162   ASSERT_NO_FATAL_FAILURE(
 163       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 164
 165   scoped_ptr<net::StreamSocket> host_socket2_;
 166   scoped_ptr<net::StreamSocket> client_socket2_;
 167   ASSERT_NO_FATAL_FAILURE(
 168       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 169
 170   ConnectSockets();
 171
 172   StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(),
 173                                 kMessageSize, kMessages);
 174   StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(),
 175                                  kMessageSize, kMessages);
 176   tester1.Start();
 177   tester2.Start();
 178   while (!tester1.done() || !tester2.done()) {
 179     message_loop_.Run();
 180   }
 181   tester1.CheckResults();
 182   tester2.CheckResults();
 183 }
 184
 185 // Four channels, two in each direction
 186 TEST_F(ChannelMultiplexerTest, FourChannels) {
 187   scoped_ptr<net::StreamSocket> host_socket1_;
 188   scoped_ptr<net::StreamSocket> client_socket1_;
 189   ASSERT_NO_FATAL_FAILURE(
 190       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 191
 192   scoped_ptr<net::StreamSocket> host_socket2_;
 193   scoped_ptr<net::StreamSocket> client_socket2_;
 194   ASSERT_NO_FATAL_FAILURE(
 195       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 196
 197   scoped_ptr<net::StreamSocket> host_socket3;
 198   scoped_ptr<net::StreamSocket> client_socket3;
 199   ASSERT_NO_FATAL_FAILURE(
 200       CreateChannel("test3", &host_socket3, &client_socket3));
 201
 202   scoped_ptr<net::StreamSocket> host_socket4;
 203   scoped_ptr<net::StreamSocket> client_socket4;
 204   ASSERT_NO_FATAL_FAILURE(
 205       CreateChannel("ch4", &host_socket4, &client_socket4));
 206
 207   ConnectSockets();
 208
 209   StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(),
 210                                 kMessageSize, kMessages);
 211   StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(),
 212                                  kMessageSize, kMessages);
 213   StreamConnectionTester tester3(client_socket3.get(), host_socket3.get(),
 214                                  kMessageSize, kMessages);
 215   StreamConnectionTester tester4(client_socket4.get(), host_socket4.get(),
 216                                  kMessageSize, kMessages);
 217   tester1.Start();
 218   tester2.Start();
 219   tester3.Start();
 220   tester4.Start();
 221   while (!tester1.done() || !tester2.done() ||
 222          !tester3.done() || !tester4.done()) {
 223     message_loop_.Run();
 224   }
 225   tester1.CheckResults();
 226   tester2.CheckResults();
 227   tester3.CheckResults();
 228   tester4.CheckResults();
 229 }
 230
 231 TEST_F(ChannelMultiplexerTest, WriteFailSync) {
 232   scoped_ptr<net::StreamSocket> host_socket1_;
 233   scoped_ptr<net::StreamSocket> client_socket1_;
 234   ASSERT_NO_FATAL_FAILURE(
 235       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 236
 237   scoped_ptr<net::StreamSocket> host_socket2_;
 238   scoped_ptr<net::StreamSocket> client_socket2_;
 239   ASSERT_NO_FATAL_FAILURE(
 240       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 241
 242   ConnectSockets();
 243
 244   host_session_.GetStreamChannel(kMuxChannelName)->
 245       set_next_write_error(net::ERR_FAILED);
 246   host_session_.GetStreamChannel(kMuxChannelName)->
 247       set_async_write(false);
 248
 249   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 250
 251   MockSocketCallback cb1;
 252   MockSocketCallback cb2;
 253
 254   EXPECT_CALL(cb1, OnDone(_))
 255       .Times(0);
 256   EXPECT_CALL(cb2, OnDone(_))
 257       .Times(0);
 258
 259   EXPECT_EQ(net::ERR_FAILED,
 260             host_socket1_->Write(buf.get(),
 261                                  buf->size(),
 262                                  base::Bind(&MockSocketCallback::OnDone,
 263                                             base::Unretained(&cb1))));
 264   EXPECT_EQ(net::ERR_FAILED,
 265             host_socket2_->Write(buf.get(),
 266                                  buf->size(),
 267                                  base::Bind(&MockSocketCallback::OnDone,
 268                                             base::Unretained(&cb2))));
 269
 270   message_loop_.RunUntilIdle();
 271 }
 272
 273 TEST_F(ChannelMultiplexerTest, WriteFailAsync) {
 274   ASSERT_NO_FATAL_FAILURE(
 275       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 276
 277   ASSERT_NO_FATAL_FAILURE(
 278       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 279
 280   ConnectSockets();
 281
 282   host_session_.GetStreamChannel(kMuxChannelName)->
 283       set_next_write_error(net::ERR_FAILED);
 284   host_session_.GetStreamChannel(kMuxChannelName)->
 285       set_async_write(true);
 286
 287   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 288
 289   MockSocketCallback cb1;
 290   MockSocketCallback cb2;
 291   EXPECT_CALL(cb1, OnDone(net::ERR_FAILED));
 292   EXPECT_CALL(cb2, OnDone(net::ERR_FAILED));
 293
 294   EXPECT_EQ(net::ERR_IO_PENDING,
 295             host_socket1_->Write(buf.get(),
 296                                  buf->size(),
 297                                  base::Bind(&MockSocketCallback::OnDone,
 298                                             base::Unretained(&cb1))));
 299   EXPECT_EQ(net::ERR_IO_PENDING,
 300             host_socket2_->Write(buf.get(),
 301                                  buf->size(),
 302                                  base::Bind(&MockSocketCallback::OnDone,
 303                                             base::Unretained(&cb2))));
 304
 305   message_loop_.RunUntilIdle();
 306 }
 307
 308 TEST_F(ChannelMultiplexerTest, DeleteWhenFailed) {
 309   ASSERT_NO_FATAL_FAILURE(
 310       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 311   ASSERT_NO_FATAL_FAILURE(
 312       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 313
 314   ConnectSockets();
 315
 316   host_session_.GetStreamChannel(kMuxChannelName)->
 317       set_next_write_error(net::ERR_FAILED);
 318   host_session_.GetStreamChannel(kMuxChannelName)->
 319       set_async_write(true);
 320
 321   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 322
 323   MockSocketCallback cb1;
 324   MockSocketCallback cb2;
 325
 326   EXPECT_CALL(cb1, OnDone(net::ERR_FAILED))
 327       .Times(AtMost(1))
 328       .WillOnce(InvokeWithoutArgs(this, &ChannelMultiplexerTest::DeleteAll));
 329   EXPECT_CALL(cb2, OnDone(net::ERR_FAILED))
 330       .Times(AtMost(1))
 331       .WillOnce(InvokeWithoutArgs(this, &ChannelMultiplexerTest::DeleteAll));
 332
 333   EXPECT_EQ(net::ERR_IO_PENDING,
 334             host_socket1_->Write(buf.get(),
 335                                  buf->size(),
 336                                  base::Bind(&MockSocketCallback::OnDone,
 337                                             base::Unretained(&cb1))));
 338   EXPECT_EQ(net::ERR_IO_PENDING,
 339             host_socket2_->Write(buf.get(),
 340                                  buf->size(),
 341                                  base::Bind(&MockSocketCallback::OnDone,
 342                                             base::Unretained(&cb2))));
 343
 344   message_loop_.RunUntilIdle();
 345
 346   // Check that the sockets were destroyed.
 347   EXPECT_FALSE(host_mux_.get());
 348 }
 349
 350 TEST_F(ChannelMultiplexerTest, SessionFail) {
 351   host_session_.set_async_creation(true);
 352   host_session_.set_error(AUTHENTICATION_FAILED);
 353
 354   MockConnectCallback cb1;
 355   MockConnectCallback cb2;
 356
 357   host_mux_->CreateStreamChannel(kTestChannelName, base::Bind(
 358       &MockConnectCallback::OnConnected, base::Unretained(&cb1)));
 359   host_mux_->CreateStreamChannel(kTestChannelName2, base::Bind(
 360       &MockConnectCallback::OnConnected, base::Unretained(&cb2)));
 361
 362   EXPECT_CALL(cb1, OnConnectedPtr(NULL))
 363       .Times(AtMost(1))
 364       .WillOnce(InvokeWithoutArgs(
 365           this, &ChannelMultiplexerTest::DeleteAfterSessionFail));
 366   EXPECT_CALL(cb2, OnConnectedPtr(_))
 367       .Times(0);
 368
 369   message_loop_.RunUntilIdle();
 370 }
 371
 372 }  // namespace protocol
 373 }  // namespace remoting