jamosdev
/
rhubarb-lip-sync
mirror of https://github.com/DanielSWolf/rhubarb-lip-sync.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rhubarb-lip-sync/lib/webrtc-8d2248ff/webrtc/p2p/quic/quictransportchannel_unitte...

557 lines
22 KiB
C++
Raw Normal View History

Added WebRTC library
2016-06-21 20:13:05 +00:00
/*
* 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.
*/
#include "webrtc/p2p/quic/quictransportchannel.h"
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "webrtc/base/common.h"
#include "webrtc/base/gunit.h"
#include "webrtc/base/sslidentity.h"
#include "webrtc/p2p/base/faketransportcontroller.h"
using cricket::ConnectionRole;
using cricket::IceRole;
using cricket::QuicTransportChannel;
using cricket::ReliableQuicStream;
using cricket::TransportChannel;
using cricket::TransportDescription;
// Timeout in milliseconds for asynchronous operations in unit tests.
static const int kTimeoutMs = 1000;
// Export keying material parameters.
static const char kExporterLabel[] = "label";
static const uint8_t kExporterContext[] = "context";
static const size_t kExporterContextLength = sizeof(kExporterContext);
static const size_t kOutputKeyLength = 20;
// Packet size for SRTP.
static const size_t kPacketSize = 100;
// Indicates ICE channel has no write error.
static const int kNoWriteError = 0;
// ICE parameters.
static const char kIceUfrag[] = "TESTICEUFRAG0001";
static const char kIcePwd[] = "TESTICEPWD00000000000001";
// QUIC packet parameters.
static const net::IPAddress kIpAddress(0, 0, 0, 0);
static const net::IPEndPoint kIpEndpoint(kIpAddress, 0);
// Detects incoming RTP packets.
static bool IsRtpLeadByte(uint8_t b) {
return (b & 0xC0) == 0x80;
}
// Maps SSL role to ICE connection role. The peer with a client role is assumed
// to be the one who initiates the connection.
static ConnectionRole SslRoleToConnectionRole(rtc::SSLRole ssl_role) {
return (ssl_role == rtc::SSL_CLIENT) ? cricket::CONNECTIONROLE_ACTIVE
: cricket::CONNECTIONROLE_PASSIVE;
}
// Allows cricket::FakeTransportChannel to simulate write blocked
// and write error states.
// TODO(mikescarlett): Add this functionality to cricket::FakeTransportChannel.
class FailableTransportChannel : public cricket::FakeTransportChannel {
public:
FailableTransportChannel(const std::string& name, int component)
: cricket::FakeTransportChannel(name, component), error_(kNoWriteError) {}
int GetError() override { return error_; }
void SetError(int error) { error_ = error; }
int SendPacket(const char* data,
size_t len,
const rtc::PacketOptions& options,
int flags) override {
if (error_ == kNoWriteError) {
return cricket::FakeTransportChannel::SendPacket(data, len, options,
flags);
}
return -1;
}
private:
int error_;
};
// Peer who establishes a handshake using a QuicTransportChannel, which wraps
// a FailableTransportChannel to simulate network connectivity and ICE
// negotiation.
class QuicTestPeer : public sigslot::has_slots<> {
public:
explicit QuicTestPeer(const std::string& name)
: name_(name),
bytes_sent_(0),
ice_channel_(new FailableTransportChannel(name_, 0)),
quic_channel_(ice_channel_),
incoming_stream_count_(0) {
quic_channel_.SignalReadPacket.connect(
this, &QuicTestPeer::OnTransportChannelReadPacket);
quic_channel_.SignalIncomingStream.connect(this,
&QuicTestPeer::OnIncomingStream);
quic_channel_.SignalClosed.connect(this, &QuicTestPeer::OnClosed);
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,
rtc::SSLFingerprint* remote_fingerprint) {
quic_channel_.SetIceRole(local_ice_role);
quic_channel_.SetIceTiebreaker(
(local_ice_role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
TransportDescription local_desc(
std::vector<std::string>(), kIceUfrag, kIcePwd, cricket::ICEMODE_FULL,
local_connection_role, local_fingerprint_.get());
TransportDescription remote_desc(
std::vector<std::string>(), kIceUfrag, kIcePwd, cricket::ICEMODE_FULL,
remote_connection_role, remote_fingerprint);
quic_channel_.SetIceCredentials(local_desc.ice_ufrag, local_desc.ice_pwd);
quic_channel_.SetRemoteIceCredentials(remote_desc.ice_ufrag,
remote_desc.ice_pwd);
}
// Creates fingerprint from certificate.
rtc::SSLFingerprint* CreateFingerprint(rtc::RTCCertificate* cert) {
std::string digest_algorithm;
bool get_digest_algorithm =
cert->ssl_certificate().GetSignatureDigestAlgorithm(&digest_algorithm);
if (!get_digest_algorithm || digest_algorithm.empty()) {
return nullptr;
}
std::unique_ptr<rtc::SSLFingerprint> fingerprint(
rtc::SSLFingerprint::Create(digest_algorithm, cert->identity()));
if (digest_algorithm != rtc::DIGEST_SHA_256) {
return nullptr;
}
return fingerprint.release();
}
// Sends SRTP packet to the other peer via |quic_channel_|.
int SendSrtpPacket() {
char packet[kPacketSize];
packet[0] = 0x80; // Make the packet header look like RTP.
int rv = quic_channel_.SendPacket(
&packet[0], kPacketSize, rtc::PacketOptions(), cricket::PF_SRTP_BYPASS);
bytes_sent_ += rv;
return rv;
}
// Sends a non-SRTP packet with the PF_SRTP_BYPASS flag via |quic_channel_|.
int SendInvalidSrtpPacket() {
char packet[kPacketSize];
// Fill the packet with 0 to form an invalid SRTP packet.
memset(packet, 0, kPacketSize);
return quic_channel_.SendPacket(
&packet[0], kPacketSize, rtc::PacketOptions(), cricket::PF_SRTP_BYPASS);
}
// Sends an RTP packet to the other peer via |quic_channel_|, without the SRTP
// bypass flag.
int SendRtpPacket() {
char packet[kPacketSize];
packet[0] = 0x80; // Make the packet header look like RTP.
return quic_channel_.SendPacket(&packet[0], kPacketSize,
rtc::PacketOptions(), 0);
}
void ClearBytesSent() { bytes_sent_ = 0; }
void ClearBytesReceived() { bytes_received_ = 0; }
void SetWriteError(int error) { ice_channel_->SetError(error); }
size_t bytes_received() const { return bytes_received_; }
size_t bytes_sent() const { return bytes_sent_; }
FailableTransportChannel* ice_channel() { return ice_channel_; }
QuicTransportChannel* quic_channel() { return &quic_channel_; }
std::unique_ptr<rtc::SSLFingerprint>& local_fingerprint() {
return local_fingerprint_;
}
ReliableQuicStream* incoming_quic_stream() { return incoming_quic_stream_; }
size_t incoming_stream_count() const { return incoming_stream_count_; }
bool signal_closed_emitted() const { return signal_closed_emitted_; }
private:
// QuicTransportChannel callbacks.
void OnTransportChannelReadPacket(TransportChannel* channel,
const char* data,
size_t size,
const rtc::PacketTime& packet_time,
int flags) {
bytes_received_ += size;
// Only SRTP packets should have the bypass flag set.
int expected_flags = IsRtpLeadByte(data[0]) ? cricket::PF_SRTP_BYPASS : 0;
ASSERT_EQ(expected_flags, flags);
}
void OnIncomingStream(ReliableQuicStream* stream) {
incoming_quic_stream_ = stream;
++incoming_stream_count_;
}
void OnClosed() { signal_closed_emitted_ = true; }
std::string name_; // Channel name.
size_t bytes_sent_; // Bytes sent by QUIC channel.
size_t bytes_received_; // Bytes received by QUIC channel.
FailableTransportChannel* ice_channel_; // Simulates an ICE channel.
QuicTransportChannel quic_channel_; // QUIC channel to test.
std::unique_ptr<rtc::SSLFingerprint> local_fingerprint_;
ReliableQuicStream* incoming_quic_stream_ = nullptr;
size_t incoming_stream_count_;
bool signal_closed_emitted_ = false;
};
class QuicTransportChannelTest : public testing::Test {
public:
QuicTransportChannelTest() : peer1_("P1"), peer2_("P2") {}
// Performs negotiation before QUIC handshake, then connects the fake
// transport channels of each peer. As a side effect, the QUIC channels
// start sending handshake messages. |peer1_| has a client role and |peer2_|
// has server role in the QUIC handshake.
void Connect() {
SetIceAndCryptoParameters(rtc::SSL_CLIENT, rtc::SSL_SERVER);
peer1_.Connect(&peer2_);
}
// Disconnects the fake transport channels.
void Disconnect() {
peer1_.Disconnect();
peer2_.Disconnect();
}
// Sets up ICE parameters and exchanges fingerprints before QUIC handshake.
void SetIceAndCryptoParameters(rtc::SSLRole peer1_ssl_role,
rtc::SSLRole peer2_ssl_role) {
peer1_.quic_channel()->SetSslRole(peer1_ssl_role);
peer2_.quic_channel()->SetSslRole(peer2_ssl_role);
std::unique_ptr<rtc::SSLFingerprint>& peer1_fingerprint =
peer1_.local_fingerprint();
std::unique_ptr<rtc::SSLFingerprint>& peer2_fingerprint =
peer2_.local_fingerprint();
peer1_.quic_channel()->SetRemoteFingerprint(
peer2_fingerprint->algorithm,
reinterpret_cast<const uint8_t*>(peer2_fingerprint->digest.data()),
peer2_fingerprint->digest.size());
peer2_.quic_channel()->SetRemoteFingerprint(
peer1_fingerprint->algorithm,
reinterpret_cast<const uint8_t*>(peer1_fingerprint->digest.data()),
peer1_fingerprint->digest.size());
ConnectionRole peer1_connection_role =
SslRoleToConnectionRole(peer1_ssl_role);
ConnectionRole peer2_connection_role =
SslRoleToConnectionRole(peer2_ssl_role);
peer1_.SetIceParameters(cricket::ICEROLE_CONTROLLED, peer1_connection_role,
peer2_connection_role, peer2_fingerprint.get());
peer2_.SetIceParameters(cricket::ICEROLE_CONTROLLING, peer2_connection_role,
peer1_connection_role, peer1_fingerprint.get());
}
// Checks if QUIC handshake is done.
bool quic_connected() {
return peer1_.quic_channel()->quic_state() ==
cricket::QUIC_TRANSPORT_CONNECTED &&
peer2_.quic_channel()->quic_state() ==
cricket::QUIC_TRANSPORT_CONNECTED;
}
// Checks if QUIC channels are writable.
bool quic_writable() {
return peer1_.quic_channel()->writable() &&
peer2_.quic_channel()->writable();
}
protected:
// QUIC peer with a client role, who initiates the QUIC handshake.
QuicTestPeer peer1_;
// QUIC peer with a server role, who responds to the client peer.
QuicTestPeer peer2_;
};
// Test that the QUIC channel passes ICE parameters to the underlying ICE
// channel.
TEST_F(QuicTransportChannelTest, ChannelSetupIce) {
SetIceAndCryptoParameters(rtc::SSL_CLIENT, rtc::SSL_SERVER);
FailableTransportChannel* channel1 = peer1_.ice_channel();
FailableTransportChannel* channel2 = peer2_.ice_channel();
EXPECT_EQ(cricket::ICEROLE_CONTROLLED, channel1->GetIceRole());
EXPECT_EQ(2u, channel1->IceTiebreaker());
EXPECT_EQ(kIceUfrag, channel1->ice_ufrag());
EXPECT_EQ(kIcePwd, channel1->ice_pwd());
EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel2->GetIceRole());
EXPECT_EQ(1u, channel2->IceTiebreaker());
}
// Test that export keying material generates identical keys for both peers
// after the QUIC handshake.
TEST_F(QuicTransportChannelTest, ExportKeyingMaterial) {
Connect();
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
uint8_t key1[kOutputKeyLength];
uint8_t key2[kOutputKeyLength];
bool from_success = peer1_.quic_channel()->ExportKeyingMaterial(
kExporterLabel, kExporterContext, kExporterContextLength, true, key1,
kOutputKeyLength);
ASSERT_TRUE(from_success);
bool to_success = peer2_.quic_channel()->ExportKeyingMaterial(
kExporterLabel, kExporterContext, kExporterContextLength, true, key2,
kOutputKeyLength);
ASSERT_TRUE(to_success);
EXPECT_EQ(0, memcmp(key1, key2, sizeof(key1)));
}
// Test that the QUIC channel is not writable before the QUIC handshake.
TEST_F(QuicTransportChannelTest, NotWritableBeforeHandshake) {
Connect();
EXPECT_FALSE(quic_writable());
Disconnect();
EXPECT_FALSE(quic_writable());
Connect();
EXPECT_FALSE(quic_writable());
}
// Test that once handshake begins, QUIC is not writable until its completion.
TEST_F(QuicTransportChannelTest, QuicHandshake) {
Connect();
EXPECT_FALSE(quic_writable());
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
EXPECT_TRUE(quic_writable());
}
// Test that Non-SRTP data is not sent using SendPacket(), regardless of QUIC
// channel state.
TEST_F(QuicTransportChannelTest, TransferNonSrtp) {
// Send data before ICE channel is connected.
peer1_.ClearBytesSent();
peer2_.ClearBytesReceived();
ASSERT_EQ(-1, peer1_.SendRtpPacket());
EXPECT_EQ(0u, peer1_.bytes_sent());
// Send data after ICE channel is connected, before QUIC handshake.
Connect();
peer1_.ClearBytesSent();
peer2_.ClearBytesReceived();
ASSERT_EQ(-1, peer1_.SendRtpPacket());
EXPECT_EQ(0u, peer1_.bytes_sent());
// Send data after QUIC handshake.
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
peer1_.ClearBytesSent();
peer2_.ClearBytesReceived();
ASSERT_EQ(-1, peer1_.SendRtpPacket());
EXPECT_EQ(0u, peer1_.bytes_sent());
}
// Test that SRTP data is always be sent, regardless of QUIC channel state, when
// the ICE channel is connected.
TEST_F(QuicTransportChannelTest, TransferSrtp) {
// Send data after ICE channel is connected, before QUIC handshake.
Connect();
peer1_.ClearBytesSent();
peer2_.ClearBytesReceived();
ASSERT_EQ(kPacketSize, static_cast<size_t>(peer1_.SendSrtpPacket()));
EXPECT_EQ_WAIT(kPacketSize, peer2_.bytes_received(), kTimeoutMs);
EXPECT_EQ(kPacketSize, peer1_.bytes_sent());
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
// Send data after QUIC handshake.
peer1_.ClearBytesSent();
peer2_.ClearBytesReceived();
ASSERT_EQ(kPacketSize, static_cast<size_t>(peer1_.SendSrtpPacket()));
EXPECT_EQ_WAIT(kPacketSize, peer2_.bytes_received(), kTimeoutMs);
EXPECT_EQ(kPacketSize, peer1_.bytes_sent());
}
// Test that invalid SRTP (non-SRTP data with
// PF_SRTP_BYPASS flag) fails to send with return value -1.
TEST_F(QuicTransportChannelTest, TransferInvalidSrtp) {
peer1_.ClearBytesSent();
peer2_.ClearBytesReceived();
EXPECT_EQ(-1, peer1_.SendInvalidSrtpPacket());
EXPECT_EQ(0u, peer2_.bytes_received());
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);
// QUIC should ignore errors when the ICE channel is writable.
peer1_.ice_channel()->SetWritable(true);
EXPECT_FALSE(peer1_.quic_channel()->IsWriteBlocked());
peer1_.SetWriteError(EWOULDBLOCK);
net::WriteResult ignore_error_result = peer1_.quic_channel()->WritePacket(
packet.data(), packet.size(), kIpAddress, kIpEndpoint, nullptr);
EXPECT_EQ(net::WRITE_STATUS_OK, ignore_error_result.status);
EXPECT_EQ(0, ignore_error_result.bytes_written);
peer1_.SetWriteError(kNoWriteError);
net::WriteResult no_error_result = peer1_.quic_channel()->WritePacket(
packet.data(), packet.size(), kIpAddress, kIpEndpoint, nullptr);
EXPECT_EQ(net::WRITE_STATUS_OK, no_error_result.status);
EXPECT_EQ(static_cast<int>(packet.size()), no_error_result.bytes_written);
}
// Test that SSL roles can be reversed before QUIC handshake.
TEST_F(QuicTransportChannelTest, QuicRoleReversalBeforeQuic) {
EXPECT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
EXPECT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_CLIENT));
EXPECT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
}
// Test that SSL roles cannot be reversed after the QUIC handshake. SetSslRole
// returns true if the current SSL role equals the proposed SSL role.
TEST_F(QuicTransportChannelTest, QuicRoleReversalAfterQuic) {
Connect();
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
EXPECT_FALSE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
EXPECT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_CLIENT));
EXPECT_FALSE(peer2_.quic_channel()->SetSslRole(rtc::SSL_CLIENT));
EXPECT_TRUE(peer2_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
}
// Set the SSL role, then test that GetSslRole returns the same value.
TEST_F(QuicTransportChannelTest, SetGetSslRole) {
ASSERT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
std::unique_ptr<rtc::SSLRole> role(new rtc::SSLRole());
ASSERT_TRUE(peer1_.quic_channel()->GetSslRole(role.get()));
EXPECT_EQ(rtc::SSL_SERVER, *role);
}
// Test that after the QUIC handshake is complete, the QUIC handshake remains
// confirmed even if the ICE channel reconnects.
TEST_F(QuicTransportChannelTest, HandshakeConfirmedAfterReconnect) {
Connect();
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
Disconnect();
EXPECT_TRUE(quic_connected());
Connect();
EXPECT_TRUE(quic_connected());
}
// Test that if the ICE channel becomes receiving after the QUIC channel is
// connected, then the QUIC channel becomes receiving.
TEST_F(QuicTransportChannelTest, IceReceivingAfterConnected) {
Connect();
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
ASSERT_FALSE(peer1_.ice_channel()->receiving());
EXPECT_FALSE(peer1_.quic_channel()->receiving());
peer1_.ice_channel()->SetReceiving(true);
EXPECT_TRUE(peer1_.quic_channel()->receiving());
}
// Test that if the ICE channel becomes receiving before the QUIC channel is
// connected, then the QUIC channel becomes receiving.
TEST_F(QuicTransportChannelTest, IceReceivingBeforeConnected) {
Connect();
peer1_.ice_channel()->SetReceiving(true);
ASSERT_TRUE(peer1_.ice_channel()->receiving());
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
EXPECT_TRUE(peer1_.quic_channel()->receiving());
}
// Test that when peer 1 creates an outgoing stream, peer 2 creates an incoming
// QUIC stream with the same ID and fires OnIncomingStream.
TEST_F(QuicTransportChannelTest, CreateOutgoingAndIncomingQuicStream) {
Connect();
EXPECT_EQ(nullptr, peer1_.quic_channel()->CreateQuicStream());
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
ReliableQuicStream* stream = peer1_.quic_channel()->CreateQuicStream();
ASSERT_NE(nullptr, stream);
stream->Write("Hi", 2);
EXPECT_TRUE_WAIT(peer2_.incoming_quic_stream() != nullptr, kTimeoutMs);
EXPECT_EQ(stream->id(), peer2_.incoming_quic_stream()->id());
}
// Test that if the QuicTransportChannel is unwritable, then all outgoing QUIC
// streams can send data once the QuicTransprotChannel becomes writable again.
TEST_F(QuicTransportChannelTest, OutgoingQuicStreamSendsDataAfterReconnect) {
Connect();
ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
ReliableQuicStream* stream1 = peer1_.quic_channel()->CreateQuicStream();
ASSERT_NE(nullptr, stream1);
ReliableQuicStream* stream2 = peer1_.quic_channel()->CreateQuicStream();
ASSERT_NE(nullptr, stream2);
peer1_.ice_channel()->SetWritable(false);
stream1->Write("First", 5);
EXPECT_EQ(5u, stream1->queued_data_bytes());
stream2->Write("Second", 6);
EXPECT_EQ(6u, stream2->queued_data_bytes());
EXPECT_EQ(0u, peer2_.incoming_stream_count());
peer1_.ice_channel()->SetWritable(true);
EXPECT_EQ_WAIT(0u, stream1->queued_data_bytes(), kTimeoutMs);
EXPECT_EQ_WAIT(0u, stream2->queued_data_bytes(), kTimeoutMs);
EXPECT_EQ_WAIT(2u, peer2_.incoming_stream_count(), kTimeoutMs);
}
// Test that SignalClosed is emitted when the QuicConnection closes.
TEST_F(QuicTransportChannelTest, SignalClosedEmitted) {
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);
}