Revert of TransportController refactoring.

webrtc/p2p/base/transport_unittest.cc

 /*
  *  Copyright 2011 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/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/network.h"
-#include "webrtc/p2p/base/faketransportcontroller.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/p2p/base/fakesession.h"
 #include "webrtc/p2p/base/p2ptransport.h"
 
 using cricket::Candidate;
 using cricket::Candidates;
 using cricket::Transport;
 using cricket::FakeTransport;
 using cricket::TransportChannel;
 using cricket::FakeTransportChannel;
 using cricket::IceRole;
 using cricket::TransportDescription;
 using rtc::SocketAddress;
 
 static const char kIceUfrag1[] = "TESTICEUFRAG0001";
 static const char kIcePwd1[] = "TESTICEPWD00000000000001";
 
 static const char kIceUfrag2[] = "TESTICEUFRAG0002";
 static const char kIcePwd2[] = "TESTICEPWD00000000000002";
 
 class TransportTest : public testing::Test,
                       public sigslot::has_slots<> {
  public:
   TransportTest()
-      : transport_(new FakeTransport("test content name")),
+      : thread_(rtc::Thread::Current()),
+        transport_(new FakeTransport(
+            thread_, thread_, "test content name", NULL)),
         channel_(NULL),
         connecting_signalled_(false),
         completed_(false),
         failed_(false) {
     transport_->SignalConnecting.connect(this, &TransportTest::OnConnecting);
     transport_->SignalCompleted.connect(this, &TransportTest::OnCompleted);
     transport_->SignalFailed.connect(this, &TransportTest::OnFailed);
   }
   ~TransportTest() {
     transport_->DestroyAllChannels();
@@ skipping 15 matching lines @@
   void OnConnecting(Transport* transport) {
     connecting_signalled_ = true;
   }
   void OnCompleted(Transport* transport) {
     completed_ = true;
   }
   void OnFailed(Transport* transport) {
     failed_ = true;
   }
 
+  rtc::Thread* thread_;
   rtc::scoped_ptr<FakeTransport> transport_;
   FakeTransportChannel* channel_;
   bool connecting_signalled_;
   bool completed_;
   bool failed_;
 };
 
 // Test that calling ConnectChannels triggers an OnConnecting signal.
 TEST_F(TransportTest, TestConnectChannelsDoesSignal) {
   EXPECT_TRUE(SetupChannel());
   transport_->ConnectChannels();
-  EXPECT_TRUE(connecting_signalled_);
+  EXPECT_FALSE(connecting_signalled_);
+
+  EXPECT_TRUE_WAIT(connecting_signalled_, 100);
+}
+
+// Test that DestroyAllChannels kills any pending OnConnecting signals.
+TEST_F(TransportTest, TestDestroyAllClearsPosts) {
+  EXPECT_TRUE(transport_->CreateChannel(1) != NULL);
+
+  transport_->ConnectChannels();
+  transport_->DestroyAllChannels();
+
+  thread_->ProcessMessages(0);
+  EXPECT_FALSE(connecting_signalled_);
 }
 
 // This test verifies channels are created with proper ICE
 // role, tiebreaker and remote ice mode and credentials after offer and
 // answer negotiations.
 TEST_F(TransportTest, TestChannelIceParameters) {
   transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);
   transport_->SetIceTiebreaker(99U);
   cricket::TransportDescription local_desc(kIceUfrag1, kIcePwd1);
   ASSERT_TRUE(transport_->SetLocalTransportDescription(local_desc,
@@ skipping 113 matching lines @@
                                                        cricket::CA_OFFER,
                                                        NULL));
   EXPECT_TRUE(SetupChannel());
 
   cricket::TransportDescription remote_desc(kIceUfrag1, kIcePwd1);
   ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,
                                                         cricket::CA_ANSWER,
                                                         NULL));
 
   channel_->SetConnectionCount(2);
-  channel_->SetCandidatesGatheringComplete();
+  channel_->SignalCandidatesAllocationDone(channel_);
   channel_->SetWritable(true);
   EXPECT_TRUE_WAIT(transport_->all_channels_writable(), 100);
   // ICE is not yet completed because there is still more than one connection.
   EXPECT_FALSE(completed_);
   EXPECT_FALSE(failed_);
 
   // When the connection count drops to 1, SignalCompleted should be emitted,
   // and completed() should be true.
   channel_->SetConnectionCount(1);
   EXPECT_TRUE_WAIT(completed_, 100);
@@ skipping 77 matching lines @@
   EXPECT_TRUE_WAIT(transport_->any_channel_receiving(), 100);
 
   channel2->SetReceiving(false);
   EXPECT_TRUE_WAIT(transport_->any_channel_receiving(), 100);
 
   // After both channels become not receiving, the transport receiving state
   // becomes TRANSPORT_STATE_NONE.
   channel_->SetReceiving(false);
   EXPECT_TRUE_WAIT(!transport_->any_channel_receiving(), 100);
 }