Revert of Separating SCTP code from BaseChannel/MediaChannel.

webrtc/media/sctp/sctptransport_unittest.cc

Index: webrtc/media/sctp/sctptransport_unittest.cc
diff --git a/webrtc/media/sctp/sctptransport_unittest.cc b/webrtc/media/sctp/sctptransport_unittest.cc
deleted file mode 100644
index 42e4dc646f37f1a646bcb101b727bf901df01682..0000000000000000000000000000000000000000
--- a/webrtc/media/sctp/sctptransport_unittest.cc
+++ /dev/null
@@ -1,563 +0,0 @@
-/*
- *  Copyright (c) 2013 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 <errno.h>
-#include <stdarg.h>
-#include <stdio.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webrtc/base/bind.h"
-#include "webrtc/base/copyonwritebuffer.h"
-#include "webrtc/base/criticalsection.h"
-#include "webrtc/base/gunit.h"
-#include "webrtc/base/helpers.h"
-#include "webrtc/base/ssladapter.h"
-#include "webrtc/base/thread.h"
-#include "webrtc/media/sctp/sctptransport.h"
-#include "webrtc/p2p/base/faketransportcontroller.h"
-
-namespace {
-static const int kDefaultTimeout = 10000;  // 10 seconds.
-// Use ports other than the default 5000 for testing.
-static const int kTransport1Port = 5001;
-static const int kTransport2Port = 5002;
-}
-
-namespace cricket {
-
-// This is essentially a buffer to hold recieved data. It stores only the last
-// received data. Calling OnDataReceived twice overwrites old data with the
-// newer one.
-// TODO(ldixon): Implement constraints, and allow new data to be added to old
-// instead of replacing it.
-class SctpFakeDataReceiver : public sigslot::has_slots<> {
- public:
-  SctpFakeDataReceiver() : received_(false) {}
-
-  void Clear() {
-    received_ = false;
-    last_data_ = "";
-    last_params_ = ReceiveDataParams();
-  }
-
-  virtual void OnDataReceived(const ReceiveDataParams& params,
-                              const rtc::CopyOnWriteBuffer& data) {
-    received_ = true;
-    last_data_ = std::string(data.data<char>(), data.size());
-    last_params_ = params;
-  }
-
-  bool received() const { return received_; }
-  std::string last_data() const { return last_data_; }
-  ReceiveDataParams last_params() const { return last_params_; }
-
- private:
-  bool received_;
-  std::string last_data_;
-  ReceiveDataParams last_params_;
-};
-
-class SignalReadyToSendObserver : public sigslot::has_slots<> {
- public:
-  SignalReadyToSendObserver() : signaled_(false) {}
-
-  void OnSignaled() { signaled_ = true; }
-
-  bool IsSignaled() { return signaled_; }
-
- private:
-  bool signaled_;
-};
-
-class SignalTransportClosedObserver : public sigslot::has_slots<> {
- public:
-  SignalTransportClosedObserver() {}
-  void BindSelf(SctpTransport* transport) {
-    transport->SignalStreamClosedRemotely.connect(
-        this, &SignalTransportClosedObserver::OnStreamClosed);
-  }
-  void OnStreamClosed(int stream) { streams_.push_back(stream); }
-
-  int StreamCloseCount(int stream) {
-    return std::count(streams_.begin(), streams_.end(), stream);
-  }
-
-  bool WasStreamClosed(int stream) {
-    return std::find(streams_.begin(), streams_.end(), stream) !=
-           streams_.end();
-  }
-
- private:
-  std::vector<int> streams_;
-};
-
-class SignalTransportClosedReopener : public sigslot::has_slots<> {
- public:
-  SignalTransportClosedReopener(SctpTransport* transport, SctpTransport* peer)
-      : transport_(transport), peer_(peer) {}
-
-  void OnStreamClosed(int stream) {
-    transport_->OpenStream(stream);
-    peer_->OpenStream(stream);
-    streams_.push_back(stream);
-  }
-
-  int StreamCloseCount(int stream) {
-    return std::count(streams_.begin(), streams_.end(), stream);
-  }
-
- private:
-  SctpTransport* transport_;
-  SctpTransport* peer_;
-  std::vector<int> streams_;
-};
-
-// SCTP Data Engine testing framework.
-class SctpTransportTest : public testing::Test, public sigslot::has_slots<> {
- protected:
-  // usrsctp uses the NSS random number generator on non-Android platforms,
-  // so we need to initialize SSL.
-  static void SetUpTestCase() {}
-
-  void SetupConnectedTransportsWithTwoStreams() {
-    fake_dtls1_.reset(new FakeTransportChannel("fake dtls 1", 0));
-    fake_dtls2_.reset(new FakeTransportChannel("fake dtls 2", 0));
-    recv1_.reset(new SctpFakeDataReceiver());
-    recv2_.reset(new SctpFakeDataReceiver());
-    transport1_.reset(CreateTransport(fake_dtls1_.get(), recv1_.get()));
-    transport1_->set_debug_name_for_testing("transport1");
-    transport1_->SignalReadyToSendData.connect(
-        this, &SctpTransportTest::OnChan1ReadyToSend);
-    transport2_.reset(CreateTransport(fake_dtls2_.get(), recv2_.get()));
-    transport2_->set_debug_name_for_testing("transport2");
-    transport2_->SignalReadyToSendData.connect(
-        this, &SctpTransportTest::OnChan2ReadyToSend);
-    // Setup two connected transports ready to send and receive.
-    bool asymmetric = false;
-    fake_dtls1_->SetDestination(fake_dtls2_.get(), asymmetric);
-
-    LOG(LS_VERBOSE) << "Transport setup ----------------------------- ";
-    AddStream(1);
-    AddStream(2);
-
-    LOG(LS_VERBOSE) << "Connect the transports -----------------------------";
-    // Both transports need to have started (with matching ports) for an
-    // association to be formed.
-    transport1_->Start(kTransport1Port, kTransport2Port);
-    transport2_->Start(kTransport2Port, kTransport1Port);
-  }
-
-  bool AddStream(int sid) {
-    bool ret = true;
-    ret = ret && transport1_->OpenStream(sid);
-    ret = ret && transport2_->OpenStream(sid);
-    return ret;
-  }
-
-  SctpTransport* CreateTransport(FakeTransportChannel* fake_dtls,
-                                 SctpFakeDataReceiver* recv) {
-    SctpTransport* transport =
-        new SctpTransport(rtc::Thread::Current(), fake_dtls);
-    // When data is received, pass it to the SctpFakeDataReceiver.
-    transport->SignalDataReceived.connect(
-        recv, &SctpFakeDataReceiver::OnDataReceived);
-    return transport;
-  }
-
-  bool SendData(SctpTransport* chan,
-                int sid,
-                const std::string& msg,
-                SendDataResult* result) {
-    SendDataParams params;
-    params.sid = sid;
-
-    return chan->SendData(params, rtc::CopyOnWriteBuffer(&msg[0], msg.length()),
-                          result);
-  }
-
-  bool ReceivedData(const SctpFakeDataReceiver* recv,
-                    int sid,
-                    const std::string& msg) {
-    return (recv->received() && recv->last_params().sid == sid &&
-            recv->last_data() == msg);
-  }
-
-  bool ProcessMessagesUntilIdle() {
-    rtc::Thread* thread = rtc::Thread::Current();
-    while (!thread->empty()) {
-      rtc::Message msg;
-      if (thread->Get(&msg, rtc::Thread::kForever)) {
-        thread->Dispatch(&msg);
-      }
-    }
-    return !thread->IsQuitting();
-  }
-
-  SctpTransport* transport1() { return transport1_.get(); }
-  SctpTransport* transport2() { return transport2_.get(); }
-  SctpFakeDataReceiver* receiver1() { return recv1_.get(); }
-  SctpFakeDataReceiver* receiver2() { return recv2_.get(); }
-  FakeTransportChannel* fake_dtls1() { return fake_dtls1_.get(); }
-  FakeTransportChannel* fake_dtls2() { return fake_dtls2_.get(); }
-
-  int transport1_ready_to_send_count() {
-    return transport1_ready_to_send_count_;
-  }
-  int transport2_ready_to_send_count() {
-    return transport2_ready_to_send_count_;
-  }
-
- private:
-  std::unique_ptr<FakeTransportChannel> fake_dtls1_;
-  std::unique_ptr<FakeTransportChannel> fake_dtls2_;
-  std::unique_ptr<SctpFakeDataReceiver> recv1_;
-  std::unique_ptr<SctpFakeDataReceiver> recv2_;
-  std::unique_ptr<SctpTransport> transport1_;
-  std::unique_ptr<SctpTransport> transport2_;
-
-  int transport1_ready_to_send_count_ = 0;
-  int transport2_ready_to_send_count_ = 0;
-
-  void OnChan1ReadyToSend() { ++transport1_ready_to_send_count_; }
-  void OnChan2ReadyToSend() { ++transport2_ready_to_send_count_; }
-};
-
-// Test that data can be sent end-to-end when an SCTP transport starts with one
-// transport channel (which is unwritable), and then switches to another
-// channel. A common scenario due to how BUNDLE works.
-TEST_F(SctpTransportTest, SwitchTransportChannel) {
-  FakeTransportChannel black_hole("black hole", 0);
-  FakeTransportChannel fake_dtls1("fake dtls 1", 0);
-  FakeTransportChannel fake_dtls2("fake dtls 2", 0);
-  SctpFakeDataReceiver recv1;
-  SctpFakeDataReceiver recv2;
-
-  // Construct transport1 with the "black hole" channel.
-  std::unique_ptr<SctpTransport> transport1(
-      CreateTransport(&black_hole, &recv1));
-  std::unique_ptr<SctpTransport> transport2(
-      CreateTransport(&fake_dtls2, &recv2));
-
-  // Add a stream.
-  transport1->OpenStream(1);
-  transport2->OpenStream(1);
-
-  // Tell them both to start (though transport1_ is connected to black_hole).
-  transport1->Start(kTransport1Port, kTransport2Port);
-  transport2->Start(kTransport2Port, kTransport1Port);
-
-  // Switch transport1_ to the normal fake_dtls1_ channel.
-  transport1->SetTransportChannel(&fake_dtls1);
-
-  // Connect the two fake DTLS channels.
-  bool asymmetric = false;
-  fake_dtls1.SetDestination(&fake_dtls2, asymmetric);
-
-  // Make sure we end up able to send data.
-  SendDataResult result;
-  ASSERT_TRUE(SendData(transport1.get(), 1, "foo", &result));
-  ASSERT_TRUE(SendData(transport2.get(), 1, "bar", &result));
-  EXPECT_TRUE_WAIT(ReceivedData(&recv2, 1, "foo"), kDefaultTimeout);
-  EXPECT_TRUE_WAIT(ReceivedData(&recv1, 1, "bar"), kDefaultTimeout);
-}
-
-// Calling Start twice shouldn't do anything bad, if with the same parameters.
-TEST_F(SctpTransportTest, DuplicateStartCallsIgnored) {
-  SetupConnectedTransportsWithTwoStreams();
-  EXPECT_TRUE(transport1()->Start(kTransport1Port, kTransport2Port));
-
-  // Make sure we can still send/recv data.
-  SendDataResult result;
-  ASSERT_TRUE(SendData(transport1(), 1, "foo", &result));
-  ASSERT_TRUE(SendData(transport2(), 1, "bar", &result));
-  EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "foo"), kDefaultTimeout);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 1, "bar"), kDefaultTimeout);
-}
-
-// Calling Start a second time with a different port should fail.
-TEST_F(SctpTransportTest, CallingStartWithDifferentPortFails) {
-  SetupConnectedTransportsWithTwoStreams();
-  EXPECT_FALSE(transport1()->Start(kTransport1Port, 1234));
-  EXPECT_FALSE(transport1()->Start(1234, kTransport2Port));
-}
-
-// A value of -1 for the local/remote port should be treated as the default
-// (5000).
-TEST_F(SctpTransportTest, NegativeOnePortTreatedAsDefault) {
-  FakeTransportChannel fake_dtls1("fake dtls 1", 0);
-  FakeTransportChannel fake_dtls2("fake dtls 2", 0);
-  SctpFakeDataReceiver recv1;
-  SctpFakeDataReceiver recv2;
-  std::unique_ptr<SctpTransport> transport1(
-      CreateTransport(&fake_dtls1, &recv1));
-  std::unique_ptr<SctpTransport> transport2(
-      CreateTransport(&fake_dtls2, &recv2));
-
-  // Add a stream.
-  transport1->OpenStream(1);
-  transport2->OpenStream(1);
-
-  // Tell them both to start, giving one transport the default port and the
-  // other transport -1.
-  transport1->Start(kSctpDefaultPort, kSctpDefaultPort);
-  transport2->Start(-1, -1);
-
-  // Connect the two fake DTLS channels.
-  bool asymmetric = false;
-  fake_dtls1.SetDestination(&fake_dtls2, asymmetric);
-
-  // Make sure we end up able to send data.
-  SendDataResult result;
-  ASSERT_TRUE(SendData(transport1.get(), 1, "foo", &result));
-  ASSERT_TRUE(SendData(transport2.get(), 1, "bar", &result));
-  EXPECT_TRUE_WAIT(ReceivedData(&recv2, 1, "foo"), kDefaultTimeout);
-  EXPECT_TRUE_WAIT(ReceivedData(&recv1, 1, "bar"), kDefaultTimeout);
-}
-
-TEST_F(SctpTransportTest, OpenStreamWithAlreadyOpenedStreamFails) {
-  FakeTransportChannel fake_dtls("fake dtls", 0);
-  SctpFakeDataReceiver recv;
-  std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
-  EXPECT_TRUE(transport->OpenStream(1));
-  EXPECT_FALSE(transport->OpenStream(1));
-}
-
-TEST_F(SctpTransportTest, ResetStreamWithAlreadyResetStreamFails) {
-  FakeTransportChannel fake_dtls("fake dtls", 0);
-  SctpFakeDataReceiver recv;
-  std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
-  EXPECT_TRUE(transport->OpenStream(1));
-  EXPECT_TRUE(transport->ResetStream(1));
-  EXPECT_FALSE(transport->ResetStream(1));
-}
-
-// Test that SignalReadyToSendData is fired after Start has been called and the
-// DTLS channel is writable.
-TEST_F(SctpTransportTest, SignalReadyToSendDataAfterDtlsWritable) {
-  FakeTransportChannel fake_dtls("fake dtls", 0);
-  SctpFakeDataReceiver recv;
-  std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
-
-  SignalReadyToSendObserver signal_observer;
-  transport->SignalReadyToSendData.connect(
-      &signal_observer, &SignalReadyToSendObserver::OnSignaled);
-
-  transport->Start(kSctpDefaultPort, kSctpDefaultPort);
-  fake_dtls.SetWritable(true);
-  EXPECT_TRUE_WAIT(signal_observer.IsSignaled(), kDefaultTimeout);
-}
-
-// Test that after an SCTP socket's buffer is filled, SignalReadyToSendData
-// is fired after it begins to be drained.
-TEST_F(SctpTransportTest, SignalReadyToSendDataAfterBlocked) {
-  SetupConnectedTransportsWithTwoStreams();
-  // Wait for initial SCTP association to be formed.
-  EXPECT_EQ_WAIT(1, transport1_ready_to_send_count(), kDefaultTimeout);
-  // Make the fake transport unwritable so that messages pile up for the SCTP
-  // socket.
-  fake_dtls1()->SetWritable(false);
-  // Send messages until we get EWOULDBLOCK.
-  static const int kMaxMessages = 1024;
-  SendDataParams params;
-  params.sid = 1;
-  rtc::CopyOnWriteBuffer buf(1024);
-  memset(buf.data<uint8_t>(), 0, 1024);
-  SendDataResult result;
-  int message_count;
-  for (message_count = 0; message_count < kMaxMessages; ++message_count) {
-    if (!transport1()->SendData(params, buf, &result) && result == SDR_BLOCK) {
-      break;
-    }
-  }
-  ASSERT_NE(kMaxMessages, message_count)
-      << "Sent max number of messages without getting SDR_BLOCK?";
-  // Make sure the ready-to-send count hasn't changed.
-  EXPECT_EQ(1, transport1_ready_to_send_count());
-  // Make the transport writable again and expect a "SignalReadyToSendData" at
-  // some point.
-  fake_dtls1()->SetWritable(true);
-  EXPECT_EQ_WAIT(2, transport1_ready_to_send_count(), kDefaultTimeout);
-}
-
-TEST_F(SctpTransportTest, SendData) {
-  SetupConnectedTransportsWithTwoStreams();
-
-  SendDataResult result;
-  LOG(LS_VERBOSE)
-      << "transport1 sending: 'hello?' -----------------------------";
-  ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
-  LOG(LS_VERBOSE) << "recv2.received=" << receiver2()->received()
-                  << ", recv2.last_params.sid="
-                  << receiver2()->last_params().sid
-                  << ", recv2.last_params.timestamp="
-                  << receiver2()->last_params().timestamp
-                  << ", recv2.last_params.seq_num="
-                  << receiver2()->last_params().seq_num
-                  << ", recv2.last_data=" << receiver2()->last_data();
-
-  LOG(LS_VERBOSE)
-      << "transport2 sending: 'hi transport1' -----------------------------";
-  ASSERT_TRUE(SendData(transport2(), 2, "hi transport1", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi transport1"),
-                   kDefaultTimeout);
-  LOG(LS_VERBOSE) << "recv1.received=" << receiver1()->received()
-                  << ", recv1.last_params.sid="
-                  << receiver1()->last_params().sid
-                  << ", recv1.last_params.timestamp="
-                  << receiver1()->last_params().timestamp
-                  << ", recv1.last_params.seq_num="
-                  << receiver1()->last_params().seq_num
-                  << ", recv1.last_data=" << receiver1()->last_data();
-}
-
-// Sends a lot of large messages at once and verifies SDR_BLOCK is returned.
-TEST_F(SctpTransportTest, SendDataBlocked) {
-  SetupConnectedTransportsWithTwoStreams();
-
-  SendDataResult result;
-  SendDataParams params;
-  params.sid = 1;
-
-  std::vector<char> buffer(1024 * 64, 0);
-
-  for (size_t i = 0; i < 100; ++i) {
-    transport1()->SendData(
-        params, rtc::CopyOnWriteBuffer(&buffer[0], buffer.size()), &result);
-    if (result == SDR_BLOCK)
-      break;
-  }
-
-  EXPECT_EQ(SDR_BLOCK, result);
-}
-
-// Trying to send data for a nonexistent stream should fail.
-TEST_F(SctpTransportTest, SendDataWithNonexistentStreamFails) {
-  SetupConnectedTransportsWithTwoStreams();
-  SendDataResult result;
-  EXPECT_FALSE(SendData(transport2(), 123, "some data", &result));
-  EXPECT_EQ(SDR_ERROR, result);
-}
-
-TEST_F(SctpTransportTest, ClosesRemoteStream) {
-  SetupConnectedTransportsWithTwoStreams();
-  SignalTransportClosedObserver transport1_sig_receiver,
-      transport2_sig_receiver;
-  transport1_sig_receiver.BindSelf(transport1());
-  transport2_sig_receiver.BindSelf(transport2());
-
-  SendDataResult result;
-  ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
-  ASSERT_TRUE(SendData(transport2(), 2, "hi transport1", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi transport1"),
-                   kDefaultTimeout);
-
-  // Close transport 1.  Transport 2 should notify us.
-  transport1()->ResetStream(1);
-  EXPECT_TRUE_WAIT(transport2_sig_receiver.WasStreamClosed(1), kDefaultTimeout);
-}
-
-TEST_F(SctpTransportTest, ClosesTwoRemoteStreams) {
-  SetupConnectedTransportsWithTwoStreams();
-  AddStream(3);
-  SignalTransportClosedObserver transport1_sig_receiver,
-      transport2_sig_receiver;
-  transport1_sig_receiver.BindSelf(transport1());
-  transport2_sig_receiver.BindSelf(transport2());
-
-  SendDataResult result;
-  ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
-  ASSERT_TRUE(SendData(transport2(), 2, "hi transport1", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi transport1"),
-                   kDefaultTimeout);
-
-  // Close two streams on one side.
-  transport2()->ResetStream(2);
-  transport2()->ResetStream(3);
-  EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(2), kDefaultTimeout);
-  EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(3), kDefaultTimeout);
-}
-
-TEST_F(SctpTransportTest, ClosesStreamsOnBothSides) {
-  SetupConnectedTransportsWithTwoStreams();
-  AddStream(3);
-  AddStream(4);
-  SignalTransportClosedObserver transport1_sig_receiver,
-      transport2_sig_receiver;
-  transport1_sig_receiver.BindSelf(transport1());
-  transport2_sig_receiver.BindSelf(transport2());
-
-  SendDataResult result;
-  ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
-  ASSERT_TRUE(SendData(transport2(), 2, "hi transport1", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi transport1"),
-                   kDefaultTimeout);
-
-  // Close one stream on transport1(), while closing three streams on
-  // transport2().  They will conflict (only one side can close anything at a
-  // time, apparently).  Test the resolution of the conflict.
-  transport1()->ResetStream(1);
-
-  transport2()->ResetStream(2);
-  transport2()->ResetStream(3);
-  transport2()->ResetStream(4);
-  EXPECT_TRUE_WAIT(transport2_sig_receiver.WasStreamClosed(1), kDefaultTimeout);
-  EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(2), kDefaultTimeout);
-  EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(3), kDefaultTimeout);
-  EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(4), kDefaultTimeout);
-}
-
-TEST_F(SctpTransportTest, RefusesHighNumberedTransports) {
-  SetupConnectedTransportsWithTwoStreams();
-  EXPECT_TRUE(AddStream(kMaxSctpSid));
-  EXPECT_FALSE(AddStream(kMaxSctpSid + 1));
-}
-
-// Flaky, see webrtc:4453.
-TEST_F(SctpTransportTest, DISABLED_ReusesAStream) {
-  // Shut down transport 1, then open it up again for reuse.
-  SetupConnectedTransportsWithTwoStreams();
-  SendDataResult result;
-  SignalTransportClosedObserver transport2_sig_receiver;
-  transport2_sig_receiver.BindSelf(transport2());
-
-  ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
-
-  transport1()->ResetStream(1);
-  EXPECT_TRUE_WAIT(transport2_sig_receiver.WasStreamClosed(1), kDefaultTimeout);
-  // Transport 1 is gone now.
-
-  // Create a new transport 1.
-  AddStream(1);
-  ASSERT_TRUE(SendData(transport1(), 1, "hi?", &result));
-  EXPECT_EQ(SDR_SUCCESS, result);
-  EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hi?"), kDefaultTimeout);
-  transport1()->ResetStream(1);
-  EXPECT_TRUE_WAIT(transport2_sig_receiver.StreamCloseCount(1) == 2,
-                   kDefaultTimeout);
-}
-
-}  // namespace cricket