clock_.AdvanceTime(delta);
}
+namespace {
+class NiceMockPacketWriterFactory
+ : public QuicConnection::PacketWriterFactory {
+ public:
+ NiceMockPacketWriterFactory() {}
+ virtual ~NiceMockPacketWriterFactory() {}
+
+ virtual QuicPacketWriter* Create(
+ QuicConnection* /*connection*/) const OVERRIDE {
+ return new testing::NiceMock<MockPacketWriter>();
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(NiceMockPacketWriterFactory);
+};
+} // namespace
+
MockConnection::MockConnection(bool is_server)
: QuicConnection(kTestConnectionId,
IPEndPoint(TestPeerIPAddress(), kTestPort),
new testing::NiceMock<MockHelper>(),
- new testing::NiceMock<MockPacketWriter>(),
- true /* owns_writer */,
+ NiceMockPacketWriterFactory(),
+ /* owns_writer= */ true,
is_server, QuicSupportedVersions()),
helper_(helper()) {
}
bool is_server)
: QuicConnection(kTestConnectionId, address,
new testing::NiceMock<MockHelper>(),
- new testing::NiceMock<MockPacketWriter>(),
- true /* owns_writer */,
+ NiceMockPacketWriterFactory(),
+ /* owns_writer= */ true,
is_server, QuicSupportedVersions()),
helper_(helper()) {
}
: QuicConnection(connection_id,
IPEndPoint(TestPeerIPAddress(), kTestPort),
new testing::NiceMock<MockHelper>(),
- new testing::NiceMock<MockPacketWriter>(),
- true /* owns_writer */,
+ NiceMockPacketWriterFactory(),
+ /* owns_writer= */ true,
is_server, QuicSupportedVersions()),
helper_(helper()) {
}
: QuicConnection(kTestConnectionId,
IPEndPoint(TestPeerIPAddress(), kTestPort),
new testing::NiceMock<MockHelper>(),
- new testing::NiceMock<MockPacketWriter>(),
- true /* owns_writer */,
+ NiceMockPacketWriterFactory(),
+ /* owns_writer= */ true,
is_server, supported_versions),
helper_(helper()) {
}
STLDeleteElements(&encrypted_packets_);
}
-bool PacketSavingConnection::SendOrQueuePacket(
- EncryptionLevel level,
- const SerializedPacket& packet,
- TransmissionType transmission_type) {
- packets_.push_back(packet.packet);
+void PacketSavingConnection::SendOrQueuePacket(QueuedPacket packet) {
+ packets_.push_back(packet.serialized_packet.packet);
QuicEncryptedPacket* encrypted = QuicConnectionPeer::GetFramer(this)->
- EncryptPacket(level, packet.sequence_number, *packet.packet);
+ EncryptPacket(packet.encryption_level,
+ packet.serialized_packet.sequence_number,
+ *packet.serialized_packet.packet);
encrypted_packets_.push_back(encrypted);
- return true;
+ // Transfer ownership of the packet to the SentPacketManager and the
+ // ack notifier to the AckNotifierManager.
+ sent_packet_manager_.OnSerializedPacket(packet.serialized_packet);
}
MockSession::MockSession(QuicConnection* connection)
return versions;
}
+TestWriterFactory::TestWriterFactory() : current_writer_(NULL) {}
+TestWriterFactory::~TestWriterFactory() {}
+
+QuicPacketWriter* TestWriterFactory::Create(QuicServerPacketWriter* writer,
+ QuicConnection* connection) {
+ return new PerConnectionPacketWriter(this, writer, connection);
+}
+
+void TestWriterFactory::OnPacketSent(WriteResult result) {
+ if (current_writer_ != NULL && result.status == WRITE_STATUS_ERROR) {
+ current_writer_->connection()->OnWriteError(result.error_code);
+ current_writer_ = NULL;
+ }
+}
+
+void TestWriterFactory::Unregister(PerConnectionPacketWriter* writer) {
+ if (current_writer_ == writer) {
+ current_writer_ = NULL;
+ }
+}
+
+TestWriterFactory::PerConnectionPacketWriter::PerConnectionPacketWriter(
+ TestWriterFactory* factory,
+ QuicServerPacketWriter* writer,
+ QuicConnection* connection)
+ : QuicPerConnectionPacketWriter(writer, connection),
+ factory_(factory) {
+}
+
+TestWriterFactory::PerConnectionPacketWriter::~PerConnectionPacketWriter() {
+ factory_->Unregister(this);
+}
+
+WriteResult TestWriterFactory::PerConnectionPacketWriter::WritePacket(
+ const char* buffer,
+ size_t buf_len,
+ const IPAddressNumber& self_address,
+ const IPEndPoint& peer_address) {
+ // A DCHECK(factory_current_writer_ == NULL) would be wrong here -- this class
+ // may be used in a setting where connection()->OnPacketSent() is called in a
+ // different way, so TestWriterFactory::OnPacketSent might never be called.
+ factory_->current_writer_ = this;
+ return QuicPerConnectionPacketWriter::WritePacket(buffer,
+ buf_len,
+ self_address,
+ peer_address);
+}
+
} // namespace test
} // namespace net