Add TransportSession interface to prepare for WebRTC-based transport.

remoting/protocol/jingle_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 "remoting/protocol/jingle_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/chromium_port_allocator.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/fake_authenticator.h"
+#include "remoting/protocol/ice_transport_factory.h"
 #include "remoting/protocol/jingle_session_manager.h"
-#include "remoting/protocol/libjingle_transport_factory.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/protocol/p2p_stream_socket.h"
 #include "remoting/protocol/stream_channel_factory.h"
 #include "remoting/signaling/fake_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::AtMost;
@@ skipping 106 matching lines @@
   void CreateSessionManagers(int auth_round_trips, int messages_till_start,
                              FakeAuthenticator::Action auth_action) {
     host_signal_strategy_.reset(new FakeSignalStrategy(kHostJid));
     client_signal_strategy_.reset(new FakeSignalStrategy(kClientJid));
     FakeSignalStrategy::Connect(host_signal_strategy_.get(),
                                 client_signal_strategy_.get());
 
     EXPECT_CALL(host_server_listener_, OnSessionManagerReady())
         .Times(1);
 
-    scoped_ptr<TransportFactory> host_transport(new LibjingleTransportFactory(
+    scoped_ptr<TransportFactory> host_transport(new IceTransportFactory(
         nullptr,
         ChromiumPortAllocator::Create(nullptr, network_settings_).Pass(),
         network_settings_, TransportRole::SERVER));
     host_server_.reset(new JingleSessionManager(host_transport.Pass()));
     host_server_->Init(host_signal_strategy_.get(), &host_server_listener_);
 
     scoped_ptr<AuthenticatorFactory> factory(
         new FakeHostAuthenticatorFactory(auth_round_trips,
           messages_till_start, auth_action, true));
     host_server_->set_authenticator_factory(factory.Pass());
 
     EXPECT_CALL(client_server_listener_, OnSessionManagerReady())
         .Times(1);
-    scoped_ptr<TransportFactory> client_transport(new LibjingleTransportFactory(
+    scoped_ptr<TransportFactory> client_transport(new IceTransportFactory(
         nullptr,
         ChromiumPortAllocator::Create(nullptr, network_settings_).Pass(),
         network_settings_, TransportRole::CLIENT));
     client_server_.reset(
         new JingleSessionManager(client_transport.Pass()));
     client_server_->Init(client_signal_strategy_.get(),
                          &client_server_listener_);
   }
 
   void CreateSessionManagers(int auth_round_trips,
@@ skipping 73 matching lines @@
     scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
         FakeAuthenticator::CLIENT, auth_round_trips, auth_action, true));
 
     client_session_ = client_server_->Connect(kHostJid, authenticator.Pass());
     client_session_->SetEventHandler(&client_session_event_handler_);
 
     base::RunLoop().RunUntilIdle();
   }
 
   void CreateChannel() {
-    client_session_->GetTransportChannelFactory()->CreateChannel(
-        kChannelName, base::Bind(&JingleSessionTest::OnClientChannelCreated,
-                                 base::Unretained(this)));
-    host_session_->GetTransportChannelFactory()->CreateChannel(
-        kChannelName, base::Bind(&JingleSessionTest::OnHostChannelCreated,
-                                 base::Unretained(this)));
+    client_session_->GetTransportSession()
+        ->GetStreamChannelFactory()
+        ->CreateChannel(kChannelName,
+                        base::Bind(&JingleSessionTest::OnClientChannelCreated,
+                                   base::Unretained(this)));
+    host_session_->GetTransportSession()
+        ->GetStreamChannelFactory()
+        ->CreateChannel(kChannelName,
+                        base::Bind(&JingleSessionTest::OnHostChannelCreated,
+                                   base::Unretained(this)));
 
     int counter = 2;
     ExpectRouteChange(kChannelName);
     EXPECT_CALL(client_channel_callback_, OnDone(_))
         .WillOnce(QuitThreadOnCounter(&counter));
     EXPECT_CALL(host_channel_callback_, OnDone(_))
         .WillOnce(QuitThreadOnCounter(&counter));
     message_loop_->Run();
 
     EXPECT_TRUE(client_socket_.get());
@@ skipping 215 matching lines @@
   client_session_ = client_server_->Connect(kHostJid, authenticator.Pass());
   base::RunLoop().RunUntilIdle();
 }
 
 // Verify that data can be sent over a multiplexed channel.
 TEST_F(JingleSessionTest, TestMuxStreamChannel) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
-  client_session_->GetMultiplexedChannelFactory()->CreateChannel(
-      kChannelName, base::Bind(&JingleSessionTest::OnClientChannelCreated,
-                               base::Unretained(this)));
-  host_session_->GetMultiplexedChannelFactory()->CreateChannel(
-      kChannelName, base::Bind(&JingleSessionTest::OnHostChannelCreated,
-                               base::Unretained(this)));
+  client_session_->GetTransportSession()
+      ->GetMultiplexedChannelFactory()
+      ->CreateChannel(kChannelName,
+                      base::Bind(&JingleSessionTest::OnClientChannelCreated,
+                                 base::Unretained(this)));
+  host_session_->GetTransportSession()
+      ->GetMultiplexedChannelFactory()
+      ->CreateChannel(kChannelName,
+                      base::Bind(&JingleSessionTest::OnHostChannelCreated,
+                                 base::Unretained(this)));
 
   int counter = 2;
   ExpectRouteChange("mux");
   EXPECT_CALL(client_channel_callback_, OnDone(_))
       .WillOnce(QuitThreadOnCounter(&counter));
   EXPECT_CALL(host_channel_callback_, OnDone(_))
       .WillOnce(QuitThreadOnCounter(&counter));
   message_loop_->Run();
 
   EXPECT_TRUE(client_socket_.get());
@@ skipping 94 matching lines @@
   message_loop_->Run();
   tester.CheckResults();
 }
 
 // Verify that we shutdown properly when channel authentication fails.
 TEST_F(JingleSessionTest, TestFailedChannelAuth) {
   CreateSessionManagers(1, FakeAuthenticator::REJECT_CHANNEL);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
-  client_session_->GetTransportChannelFactory()->CreateChannel(
-      kChannelName, base::Bind(&JingleSessionTest::OnClientChannelCreated,
-                               base::Unretained(this)));
-  host_session_->GetTransportChannelFactory()->CreateChannel(
-      kChannelName, base::Bind(&JingleSessionTest::OnHostChannelCreated,
-                               base::Unretained(this)));
+  client_session_->GetTransportSession()
+      ->GetStreamChannelFactory()
+      ->CreateChannel(kChannelName,
+                      base::Bind(&JingleSessionTest::OnClientChannelCreated,
+                                 base::Unretained(this)));
+  host_session_->GetTransportSession()
+      ->GetStreamChannelFactory()
+      ->CreateChannel(kChannelName,
+                      base::Bind(&JingleSessionTest::OnHostChannelCreated,
+                                 base::Unretained(this)));
 
   // Terminate the message loop when we get rejection notification
   // from the host.
   EXPECT_CALL(host_channel_callback_, OnDone(nullptr))
       .WillOnce(QuitThread());
   ExpectRouteChange(kChannelName);
 
   message_loop_->Run();
 
-  client_session_->GetTransportChannelFactory()->CancelChannelCreation(
-      kChannelName);
+  client_session_->GetTransportSession()
+      ->GetStreamChannelFactory()
+      ->CancelChannelCreation(kChannelName);
 
   EXPECT_TRUE(!host_socket_.get());
 }
 
 TEST_F(JingleSessionTest, TestCancelChannelCreation) {
   CreateSessionManagers(1, FakeAuthenticator::REJECT_CHANNEL);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
-  client_session_->GetTransportChannelFactory()->CreateChannel(
-      kChannelName, base::Bind(&JingleSessionTest::OnClientChannelCreated,
-                               base::Unretained(this)));
-  client_session_->GetTransportChannelFactory()->CancelChannelCreation(
-      kChannelName);
+  client_session_->GetTransportSession()
+      ->GetStreamChannelFactory()
+      ->CreateChannel(kChannelName,
+                      base::Bind(&JingleSessionTest::OnClientChannelCreated,
+                                 base::Unretained(this)));
+  client_session_->GetTransportSession()
+      ->GetStreamChannelFactory()
+      ->CancelChannelCreation(kChannelName);
 
   EXPECT_TRUE(!client_socket_.get());
 }
 
 // Verify that we can still connect even when there is a delay in signaling
 // messages delivery.
 TEST_F(JingleSessionTest, TestDelayedSignaling) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
   host_signal_strategy_->set_send_delay(
       base::TimeDelta::FromMilliseconds(100));
 
   ASSERT_NO_FATAL_FAILURE(CreateChannel());
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, 1);
   tester.Start();
   message_loop_->Run();
   tester.CheckResults();
 }
 
 }  // namespace protocol
 }  // namespace remoting