TransportController refactoring

webrtc/p2p/base/transportcontroller_unittest.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/p2p/base/dtlstransportchannel.h"
 #include "webrtc/p2p/base/p2ptransportchannel.h"
 #include "webrtc/p2p/base/portallocator.h"
-#include "webrtc/p2p/base/session.h"
+#include "webrtc/p2p/base/transportcontroller.h"
 #include "webrtc/p2p/base/transportchannelproxy.h"
 #include "webrtc/p2p/client/fakeportallocator.h"
 
-using cricket::BaseSession;
+using cricket::TransportController;
+using cricket::TransportChannel;
 using cricket::DtlsTransportChannelWrapper;
 using cricket::FakePortAllocator;
 using cricket::P2PTransportChannel;
 using cricket::PortAllocator;
 using cricket::TransportChannelProxy;
-using cricket::TransportProxy;
 
-class BaseSessionForTest : public BaseSession {
+class TransportControllerForTest : public TransportController {
  public:
-  BaseSessionForTest(rtc::Thread* signaling_thread,
-                     rtc::Thread* worker_thread,
-                     PortAllocator* port_allocator,
-                     const std::string& sid,
-                     const std::string& content_type,
-                     bool initiator)
-      : BaseSession(signaling_thread,
-                    worker_thread,
-                    port_allocator,
-                    sid,
-                    content_type,
-                    initiator) {}
-  using BaseSession::GetOrCreateTransportProxy;
+  TransportControllerForTest(rtc::Thread* signaling_thread,
+                             rtc::Thread* worker_thread,
+                             PortAllocator* port_allocator,
+                             bool initiator)
+      : TransportController(signaling_thread, worker_thread, port_allocator) {
+    SetIceRole(initiator ? cricket::ICEROLE_CONTROLLING
+                         : cricket::ICEROLE_CONTROLLED);
+  }
 };
 
-class BaseSessionTest : public testing::Test {
+class TransportControllerTest : public testing::Test {
  public:
-  BaseSessionTest()
+  TransportControllerTest()
       : port_allocator_(new FakePortAllocator(rtc::Thread::Current(), nullptr)),
-        session_(new BaseSessionForTest(rtc::Thread::Current(),
-                                        rtc::Thread::Current(),
-                                        port_allocator_.get(),
-                                        "123",
-                                        cricket::NS_JINGLE_RTP,
-                                        false)) {}
+        transport_controller_(
+            new TransportControllerForTest(rtc::Thread::Current(),
+                                           rtc::Thread::Current(),
+                                           port_allocator_.get(),
+                                           false)) {}
+
   P2PTransportChannel* CreateChannel(const std::string& content,
                                      int component) {
-    TransportProxy* transport_proxy =
-        session_->GetOrCreateTransportProxy(content);
-    // This hacking is needed in order that the p2p transport channel
-    // will be created in the following.
-    transport_proxy->CompleteNegotiation();
-
-    TransportChannelProxy* channel_proxy = static_cast<TransportChannelProxy*>(
-        session_->CreateChannel(content, component));
+    TransportChannel* channel =
+        transport_controller_->CreateTransportChannel_w(content, component);
     DtlsTransportChannelWrapper* dtls_channel =
-        static_cast<DtlsTransportChannelWrapper*>(channel_proxy->impl());
+        static_cast<DtlsTransportChannelWrapper*>(channel);
     return static_cast<P2PTransportChannel*>(dtls_channel->channel());
   }
 
   rtc::scoped_ptr<PortAllocator> port_allocator_;
-  rtc::scoped_ptr<BaseSessionForTest> session_;
+  rtc::scoped_ptr<TransportControllerForTest> transport_controller_;
 };
 
-TEST_F(BaseSessionTest, TestSetIceReceivingTimeout) {
+TEST_F(TransportControllerTest, TestSetIceReceivingTimeout) {
   P2PTransportChannel* channel1 = CreateChannel("audio", 1);
   ASSERT_NE(channel1, nullptr);
   // These are the default values.
   EXPECT_EQ(2500, channel1->receiving_timeout());
   EXPECT_EQ(250, channel1->check_receiving_delay());
   // Set the timeout to a different value.
-  session_->SetIceConnectionReceivingTimeout(1000);
+  transport_controller_->SetIceConnectionReceivingTimeout(1000);
   EXPECT_EQ(1000, channel1->receiving_timeout());
   EXPECT_EQ(100, channel1->check_receiving_delay());
 
   // Even if a channel is created after setting the receiving timeout,
   // the set timeout value is applied to the new channel.
   P2PTransportChannel* channel2 = CreateChannel("video", 2);
   ASSERT_NE(channel2, nullptr);
   EXPECT_EQ(1000, channel2->receiving_timeout());
   EXPECT_EQ(100, channel2->check_receiving_delay());
 
   // Test minimum checking delay.
-  session_->SetIceConnectionReceivingTimeout(200);
+  transport_controller_->SetIceConnectionReceivingTimeout(200);
   EXPECT_EQ(200, channel1->receiving_timeout());
   EXPECT_EQ(50, channel1->check_receiving_delay());
   EXPECT_EQ(200, channel2->receiving_timeout());
   EXPECT_EQ(50, channel2->check_receiving_delay());
 }

[pthatcher2, 2015/08/19 18:32:16]

I think we need to add a lot more tests.  Sorry, we're paying up for the fact
that this wasn't well tested before.

1.  Test that CreateTransportChannel/DeleteTransportChannel work correctly with
setting the correct values on the created transport (which is created on demand
and deleted on demand).

2.  Make sure that setting certain cross-Transport values works (ice_role,
ssl_role, identity, etc) before and after creating a transport on demand.

3.  Getting cross-Transport values works, such as ice_role, ssl_role).

4.  Getting per-Transport values works, such as stats.

5.  Setting per-Transport things works, such as SetLocal and
SetRemoteDescription.

6.  The state aggregation works properly.

7.  Candidates get signalled up properly.

8.  ICE role conflict reversing works properly.

9.  The thread hopping happens properly (that might be harder to test, not
sure).

[Taylor Brandstetter, 2015/08/27 22:15:57]

Done.