Refactoring on QUIC

webrtc/p2p/quic/quictransportchannel_unittest.cc

 /*
  *  Copyright 2016 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.
  */
 
@@ skipping 94 matching lines @@
     ice_channel_->SetAsync(true);
     rtc::scoped_refptr<rtc::RTCCertificate> local_cert =
         rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(name_, rtc::KT_DEFAULT)));
     quic_channel_.SetLocalCertificate(local_cert);
     local_fingerprint_.reset(CreateFingerprint(local_cert.get()));
   }
 
   // Connects |ice_channel_| to that of the other peer.
   void Connect(QuicTestPeer* other_peer) {
-    ice_channel_->Connect();
-    other_peer->ice_channel_->Connect();
     ice_channel_->SetDestination(other_peer->ice_channel_);
   }
 
   // Disconnects |ice_channel_|.
   void Disconnect() { ice_channel_->SetDestination(nullptr); }
 
   // Generates ICE credentials and passes them to |quic_channel_|.
   void SetIceParameters(IceRole local_ice_role,
                         ConnectionRole local_connection_role,
                         ConnectionRole remote_connection_role,
@@ skipping 285 matching lines @@
   Connect();
   peer1_.ClearBytesSent();
   peer2_.ClearBytesReceived();
   EXPECT_EQ(-1, peer1_.SendInvalidSrtpPacket());
   EXPECT_EQ(0u, peer2_.bytes_received());
 }
 
 // Test that QuicTransportChannel::WritePacket blocks when the ICE
 // channel is not writable, and otherwise succeeds.
 TEST_F(QuicTransportChannelTest, QuicWritePacket) {
-  peer1_.ice_channel()->Connect();
-  peer2_.ice_channel()->Connect();
   peer1_.ice_channel()->SetDestination(peer2_.ice_channel());
   std::string packet = "FAKEQUICPACKET";
 
   // QUIC should be write blocked when the ICE channel is not writable.
   peer1_.ice_channel()->SetWritable(false);
   EXPECT_TRUE(peer1_.quic_channel()->IsWriteBlocked());
   net::WriteResult write_blocked_result = peer1_.quic_channel()->WritePacket(
       packet.data(), packet.size(), kIpAddress, kIpEndpoint, nullptr);
   EXPECT_EQ(net::WRITE_STATUS_BLOCKED, write_blocked_result.status);
   EXPECT_EQ(EWOULDBLOCK, write_blocked_result.error_code);
@@ skipping 113 matching lines @@
   Connect();
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   ASSERT_FALSE(peer1_.signal_closed_emitted());
   ReliableQuicStream* stream = peer1_.quic_channel()->CreateQuicStream();
   ASSERT_NE(nullptr, stream);
   stream->CloseConnectionWithDetails(net::QuicErrorCode::QUIC_NO_ERROR,
                                      "Closing QUIC for testing");
   EXPECT_TRUE(peer1_.signal_closed_emitted());
   EXPECT_TRUE_WAIT(peer2_.signal_closed_emitted(), kTimeoutMs);
 }