From c1223a2f78ba24505b34510322d7dbc7e9838845 Mon Sep 17 00:00:00 2001 From: Yang Chi Date: Wed, 16 Dec 2020 18:01:40 -0800 Subject: [PATCH] Remove trailing `_E` from QUIC variant type Summary: I think this should just work without the trailing `_E`. It was added when we mixed up our own union based variant and boost::variant. Some compiler flags didn't like that. Now we no longer have mixed up cases, this should be fine Reviewed By: lnicco Differential Revision: D25589393 fbshipit-source-id: 6430dc20f8e81af0329d89e6990c16826da168b8 --- quic/QuicException.cpp | 12 +- quic/api/QuicTransportBase.cpp | 10 +- quic/api/QuicTransportFunctions.cpp | 32 +-- quic/api/test/QuicPacketSchedulerTest.cpp | 6 +- quic/api/test/QuicTransportBaseTest.cpp | 4 +- quic/api/test/QuicTransportFunctionsTest.cpp | 4 +- quic/api/test/QuicTransportTest.cpp | 28 +- quic/client/QuicClientTransport.cpp | 38 +-- quic/codec/QuicPacketRebuilder.cpp | 16 +- quic/codec/QuicPacketRebuilder.h | 2 +- quic/codec/QuicWriteCodec.cpp | 40 +-- quic/codec/test/QuicPacketRebuilderTest.cpp | 18 +- quic/common/Variant.h | 36 +-- quic/common/test/TestUtils.cpp | 12 +- quic/common/test/VariantTest.cpp | 6 +- .../client/test/QuicClientTransportTest.cpp | 26 +- quic/flowcontrol/test/QuicFlowControlTest.cpp | 8 +- quic/logging/BaseQLogger.cpp | 74 ++--- quic/loss/QuicLossFunctions.cpp | 16 +- quic/loss/test/QuicLossFunctionsTest.cpp | 6 +- quic/server/state/ServerStateMachine.cpp | 40 +-- quic/server/test/QuicServerTransportTest.cpp | 67 +++-- quic/state/QPRFunctions.cpp | 2 +- quic/state/SimpleFrameFunctions.cpp | 62 ++--- quic/state/StateData.cpp | 4 +- quic/state/StreamData.h | 40 ++- quic/state/stream/StreamReceiveHandlers.cpp | 16 +- quic/state/stream/StreamSendHandlers.cpp | 38 +-- .../stream/test/StreamStateMachineTest.cpp | 258 +++++++++--------- quic/state/test/QPRFunctionsTest.cpp | 4 +- quic/state/test/QuicStateFunctionsTest.cpp | 6 +- quic/state/test/QuicStreamFunctionsTest.cpp | 14 +- quic/state/test/QuicStreamManagerTest.cpp | 32 +-- 33 files changed, 483 insertions(+), 494 deletions(-) diff --git a/quic/QuicException.cpp b/quic/QuicException.cpp index 52fd3adff..16d640b15 100644 --- a/quic/QuicException.cpp +++ b/quic/QuicException.cpp @@ -181,15 +181,15 @@ std::string cryptoErrorToString(TransportErrorCode code) { std::string toString(QuicErrorCode code) { switch (code.type()) { - case QuicErrorCode::Type::ApplicationErrorCode_E: + case QuicErrorCode::Type::ApplicationErrorCode: if (*code.asApplicationErrorCode() == GenericApplicationErrorCode::NO_ERROR) { return "No Error"; } return folly::to(*code.asApplicationErrorCode()); - case QuicErrorCode::Type::LocalErrorCode_E: + case QuicErrorCode::Type::LocalErrorCode: return toString(*code.asLocalErrorCode()).str(); - case QuicErrorCode::Type::TransportErrorCode_E: + case QuicErrorCode::Type::TransportErrorCode: return toString(*code.asTransportErrorCode()); } folly::assume_unreachable(); @@ -200,16 +200,16 @@ std::string toString( error) { std::string err; switch (error.first.type()) { - case QuicErrorCode::Type::ApplicationErrorCode_E: + case QuicErrorCode::Type::ApplicationErrorCode: err = "ApplicationError: " + toString(*error.first.asApplicationErrorCode()) + ", "; break; - case QuicErrorCode::Type::LocalErrorCode_E: + case QuicErrorCode::Type::LocalErrorCode: err = "LocalError: " + folly::to(toString(*error.first.asLocalErrorCode())) + ", "; break; - case QuicErrorCode::Type::TransportErrorCode_E: + case QuicErrorCode::Type::TransportErrorCode: err = "TransportError: " + toString(*error.first.asTransportErrorCode()) + ", "; } diff --git a/quic/api/QuicTransportBase.cpp b/quic/api/QuicTransportBase.cpp index 2fa88781b..cac28734f 100644 --- a/quic/api/QuicTransportBase.cpp +++ b/quic/api/QuicTransportBase.cpp @@ -430,19 +430,19 @@ void QuicTransportBase::closeImpl( if (connCallback_) { bool noError = false; switch (cancelCode.first.type()) { - case QuicErrorCode::Type::LocalErrorCode_E: { + case QuicErrorCode::Type::LocalErrorCode: { LocalErrorCode localErrorCode = *cancelCode.first.asLocalErrorCode(); noError = localErrorCode == LocalErrorCode::NO_ERROR || localErrorCode == LocalErrorCode::IDLE_TIMEOUT; break; } - case QuicErrorCode::Type::TransportErrorCode_E: { + case QuicErrorCode::Type::TransportErrorCode: { TransportErrorCode transportErrorCode = *cancelCode.first.asTransportErrorCode(); noError = transportErrorCode == TransportErrorCode::NO_ERROR; break; } - case QuicErrorCode::Type::ApplicationErrorCode_E: + case QuicErrorCode::Type::ApplicationErrorCode: auto appErrorCode = *cancelCode.first.asApplicationErrorCode(); noError = appErrorCode == GenericApplicationErrorCode::NO_ERROR; } @@ -1467,7 +1467,7 @@ folly::Expected QuicTransportBase::peek( if (stream->streamReadError) { switch (stream->streamReadError->type()) { - case QuicErrorCode::Type::LocalErrorCode_E: + case QuicErrorCode::Type::LocalErrorCode: return folly::makeUnexpected( *stream->streamReadError->asLocalErrorCode()); default: @@ -1525,7 +1525,7 @@ folly:: if (stream->streamReadError) { switch (stream->streamReadError->type()) { - case QuicErrorCode::Type::LocalErrorCode_E: + case QuicErrorCode::Type::LocalErrorCode: return folly::makeUnexpected(ConsumeError{ *stream->streamReadError->asLocalErrorCode(), folly::none}); default: diff --git a/quic/api/QuicTransportFunctions.cpp b/quic/api/QuicTransportFunctions.cpp index 5d775c224..46a141e93 100644 --- a/quic/api/QuicTransportFunctions.cpp +++ b/quic/api/QuicTransportFunctions.cpp @@ -493,7 +493,7 @@ void updateConnection( } for (const auto& frame : packet.frames) { switch (frame.type()) { - case QuicWriteFrame::Type::WriteStreamFrame_E: { + case QuicWriteFrame::Type::WriteStreamFrame: { const WriteStreamFrame& writeStreamFrame = *frame.asWriteStreamFrame(); retransmittable = true; auto stream = CHECK_NOTNULL( @@ -516,7 +516,7 @@ void updateConnection( conn.streamManager->updateLossStreams(*stream); break; } - case QuicWriteFrame::Type::WriteCryptoFrame_E: { + case QuicWriteFrame::Type::WriteCryptoFrame: { const WriteCryptoFrame& writeCryptoFrame = *frame.asWriteCryptoFrame(); retransmittable = true; auto protectionType = packet.header.getProtectionType(); @@ -536,7 +536,7 @@ void updateConnection( packetNumberSpace); break; } - case QuicWriteFrame::Type::WriteAckFrame_E: { + case QuicWriteFrame::Type::WriteAckFrame: { const WriteAckFrame& writeAckFrame = *frame.asWriteAckFrame(); DCHECK(!ackFrameCounter++) << "Send more than one WriteAckFrame " << conn; @@ -551,7 +551,7 @@ void updateConnection( largestAckedPacketWritten); break; } - case QuicWriteFrame::Type::RstStreamFrame_E: { + case QuicWriteFrame::Type::RstStreamFrame: { const RstStreamFrame& rstStreamFrame = *frame.asRstStreamFrame(); retransmittable = true; VLOG(10) << nodeToString(conn.nodeType) @@ -569,7 +569,7 @@ void updateConnection( } break; } - case QuicWriteFrame::Type::MaxDataFrame_E: { + case QuicWriteFrame::Type::MaxDataFrame: { const MaxDataFrame& maxDataFrame = *frame.asMaxDataFrame(); CHECK(!connWindowUpdateSent++) << "Send more than one connection window update " << conn; @@ -583,7 +583,7 @@ void updateConnection( onConnWindowUpdateSent(conn, maxDataFrame.maximumData, sentTime); break; } - case QuicWriteFrame::Type::DataBlockedFrame_E: { + case QuicWriteFrame::Type::DataBlockedFrame: { VLOG(10) << nodeToString(conn.nodeType) << " sent conn data blocked frame=" << packetNum << " " << conn; @@ -591,7 +591,7 @@ void updateConnection( conn.pendingEvents.sendDataBlocked = false; break; } - case QuicWriteFrame::Type::MaxStreamDataFrame_E: { + case QuicWriteFrame::Type::MaxStreamDataFrame: { const MaxStreamDataFrame& maxStreamDataFrame = *frame.asMaxStreamDataFrame(); auto stream = CHECK_NOTNULL( @@ -604,7 +604,7 @@ void updateConnection( *stream, maxStreamDataFrame.maximumData, sentTime); break; } - case QuicWriteFrame::Type::StreamDataBlockedFrame_E: { + case QuicWriteFrame::Type::StreamDataBlockedFrame: { const StreamDataBlockedFrame& streamBlockedFrame = *frame.asStreamDataBlockedFrame(); VLOG(10) << nodeToString(conn.nodeType) @@ -614,7 +614,7 @@ void updateConnection( conn.streamManager->removeBlocked(streamBlockedFrame.streamId); break; } - case QuicWriteFrame::Type::PingFrame_E: + case QuicWriteFrame::Type::PingFrame: // If this is a d6d probe, the it does not consume the sendPing request // from application, because this packet, albeit containing a ping // frame, is larger than the current PMTU and will potentially get @@ -626,7 +626,7 @@ void updateConnection( } isPing = true; break; - case QuicWriteFrame::Type::QuicSimpleFrame_E: { + case QuicWriteFrame::Type::QuicSimpleFrame: { const QuicSimpleFrame& simpleFrame = *frame.asQuicSimpleFrame(); retransmittable = true; // We don't want this triggered for cloned frames. @@ -635,7 +635,7 @@ void updateConnection( } break; } - case QuicWriteFrame::Type::PaddingFrame_E: { + case QuicWriteFrame::Type::PaddingFrame: { // do not mark padding as retransmittable. There are several reasons // for this: // 1. We might need to pad ACK packets to make it so that we can @@ -998,7 +998,7 @@ void writeCloseCommon( packetBuilder); } else { switch (closeDetails->first.type()) { - case QuicErrorCode::Type::ApplicationErrorCode_E: + case QuicErrorCode::Type::ApplicationErrorCode: written = writeFrame( ConnectionCloseFrame( QuicErrorCode(*closeDetails->first.asApplicationErrorCode()), @@ -1006,7 +1006,7 @@ void writeCloseCommon( quic::FrameType::CONNECTION_CLOSE_APP_ERR), packetBuilder); break; - case QuicErrorCode::Type::TransportErrorCode_E: + case QuicErrorCode::Type::TransportErrorCode: written = writeFrame( ConnectionCloseFrame( QuicErrorCode(*closeDetails->first.asTransportErrorCode()), @@ -1014,7 +1014,7 @@ void writeCloseCommon( quic::FrameType::CONNECTION_CLOSE), packetBuilder); break; - case QuicErrorCode::Type::LocalErrorCode_E: + case QuicErrorCode::Type::LocalErrorCode: written = writeFrame( ConnectionCloseFrame( QuicErrorCode(TransportErrorCode::INTERNAL_ERROR), @@ -1509,14 +1509,14 @@ void implicitAckCryptoStream( implicitAck, [&](auto&, auto& packetFrame, auto&) { switch (packetFrame.type()) { - case QuicWriteFrame::Type::WriteCryptoFrame_E: { + case QuicWriteFrame::Type::WriteCryptoFrame: { const WriteCryptoFrame& frame = *packetFrame.asWriteCryptoFrame(); auto cryptoStream = getCryptoStream(*conn.cryptoState, encryptionLevel); processCryptoStreamAck(*cryptoStream, frame.offset, frame.len); break; } - case QuicWriteFrame::Type::WriteAckFrame_E: { + case QuicWriteFrame::Type::WriteAckFrame: { const WriteAckFrame& frame = *packetFrame.asWriteAckFrame(); commonAckVisitorForAckFrame(ackState, frame); break; diff --git a/quic/api/test/QuicPacketSchedulerTest.cpp b/quic/api/test/QuicPacketSchedulerTest.cpp index 609274b20..9bdcc790e 100644 --- a/quic/api/test/QuicPacketSchedulerTest.cpp +++ b/quic/api/test/QuicPacketSchedulerTest.cpp @@ -755,18 +755,18 @@ TEST_F(QuicPacketSchedulerTest, CloneWillGenerateNewWindowUpdate) { int32_t verifyConnWindowUpdate = 1, verifyStreamWindowUpdate = 1; for (const auto& frame : packetResult.packet->packet.frames) { switch (frame.type()) { - case QuicWriteFrame::Type::MaxStreamDataFrame_E: { + case QuicWriteFrame::Type::MaxStreamDataFrame: { const MaxStreamDataFrame& maxStreamDataFrame = *frame.asMaxStreamDataFrame(); EXPECT_EQ(stream->id, maxStreamDataFrame.streamId); verifyStreamWindowUpdate--; break; } - case QuicWriteFrame::Type::MaxDataFrame_E: { + case QuicWriteFrame::Type::MaxDataFrame: { verifyConnWindowUpdate--; break; } - case QuicWriteFrame::Type::PaddingFrame_E: { + case QuicWriteFrame::Type::PaddingFrame: { break; } default: diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp index 9af639e87..73dd3d4a7 100644 --- a/quic/api/test/QuicTransportBaseTest.cpp +++ b/quic/api/test/QuicTransportBaseTest.cpp @@ -349,8 +349,8 @@ class TestQuicTransport void closeStream(StreamId id) { QuicStreamState* stream = conn_->streamManager->getStream(id); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; conn_->streamManager->addClosed(id); auto deliveryCb = deliveryCallbacks_.find(id); diff --git a/quic/api/test/QuicTransportFunctionsTest.cpp b/quic/api/test/QuicTransportFunctionsTest.cpp index 571667500..5de1e4339 100644 --- a/quic/api/test/QuicTransportFunctionsTest.cpp +++ b/quic/api/test/QuicTransportFunctionsTest.cpp @@ -1461,7 +1461,7 @@ TEST_F(QuicTransportFunctionsTest, WriteBlockedFrameWhenBlocked) { EXPECT_GT(conn->ackStates.appDataAckState.nextPacketNum, originalNextSeq); auto blocked = *getFirstFrameInOutstandingPackets( conn->outstandings.packets, - QuicWriteFrame::Type::StreamDataBlockedFrame_E) + QuicWriteFrame::Type::StreamDataBlockedFrame) .asStreamDataBlockedFrame(); EXPECT_EQ(blocked.streamId, stream1->id); @@ -2321,7 +2321,7 @@ TEST_F(QuicTransportFunctionsTest, ProbeWriteNewFunctionalFrames) { EXPECT_EQ(2, conn->outstandings.packets.size()); EXPECT_EQ(1, conn->outstandings.packets[1].packet.frames.size()); EXPECT_EQ( - QuicWriteFrame::Type::MaxDataFrame_E, + QuicWriteFrame::Type::MaxDataFrame, conn->outstandings.packets[1].packet.frames[0].type()); } diff --git a/quic/api/test/QuicTransportTest.cpp b/quic/api/test/QuicTransportTest.cpp index 6870763d7..0daa168dc 100644 --- a/quic/api/test/QuicTransportTest.cpp +++ b/quic/api/test/QuicTransportTest.cpp @@ -882,7 +882,7 @@ TEST_F(QuicTransportTest, RstStream) { auto stream = transport_->getConnectionState().streamManager->findStream(streamId); ASSERT_TRUE(stream); - EXPECT_EQ(stream->sendState, StreamSendState::ResetSent_E); + EXPECT_EQ(stream->sendState, StreamSendState::ResetSent); EXPECT_TRUE(stream->retransmissionBuffer.empty()); EXPECT_TRUE(stream->writeBuffer.empty()); EXPECT_FALSE(stream->writable()); @@ -1126,7 +1126,7 @@ TEST_F(QuicTransportTest, ClonePathChallenge) { auto numPathChallengePackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_EQ(numPathChallengePackets, 1); // Force a timeout with no data so that it clones the packet @@ -1135,7 +1135,7 @@ TEST_F(QuicTransportTest, ClonePathChallenge) { numPathChallengePackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_EQ(numPathChallengePackets, 2); } @@ -1159,7 +1159,7 @@ TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) { auto numPathChallengePackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_EQ(numPathChallengePackets, 1); // Reset outstandingPathValidation @@ -1172,7 +1172,7 @@ TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) { numPathChallengePackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_EQ(numPathChallengePackets, 1); } @@ -1302,7 +1302,7 @@ TEST_F(QuicTransportTest, ClonePathResponse) { auto numPathResponsePackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_EQ(numPathResponsePackets, 1); // Force a timeout with no data so that it clones the packet @@ -1310,7 +1310,7 @@ TEST_F(QuicTransportTest, ClonePathResponse) { numPathResponsePackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_EQ(numPathResponsePackets, 1); } @@ -1385,7 +1385,7 @@ TEST_F(QuicTransportTest, CloneNewConnectionIdFrame) { auto numNewConnIdPackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_EQ(numNewConnIdPackets, 1); // Force a timeout with no data so that it clones the packet @@ -1394,7 +1394,7 @@ TEST_F(QuicTransportTest, CloneNewConnectionIdFrame) { numNewConnIdPackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_EQ(numNewConnIdPackets, 2); } @@ -1524,8 +1524,7 @@ TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) { auto numRetireConnIdPackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc< - QuicSimpleFrame::Type::RetireConnectionIdFrame_E>()); + findFrameInPacketFunc()); EXPECT_EQ(numRetireConnIdPackets, 1); // Force a timeout with no data so that it clones the packet @@ -1534,8 +1533,7 @@ TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) { numRetireConnIdPackets = std::count_if( conn.outstandings.packets.begin(), conn.outstandings.packets.end(), - findFrameInPacketFunc< - QuicSimpleFrame::Type::RetireConnectionIdFrame_E>()); + findFrameInPacketFunc()); EXPECT_EQ(numRetireConnIdPackets, 2); } @@ -1629,7 +1627,7 @@ TEST_F(QuicTransportTest, RstWrittenStream) { } EXPECT_TRUE(foundReset); - EXPECT_EQ(stream->sendState, StreamSendState::ResetSent_E); + EXPECT_EQ(stream->sendState, StreamSendState::ResetSent); EXPECT_TRUE(stream->retransmissionBuffer.empty()); EXPECT_TRUE(stream->writeBuffer.empty()); EXPECT_FALSE(stream->writable()); @@ -1699,7 +1697,7 @@ TEST_F(QuicTransportTest, WriteAfterSendRst) { transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN); loopForWrites(); - EXPECT_EQ(stream->sendState, StreamSendState::ResetSent_E); + EXPECT_EQ(stream->sendState, StreamSendState::ResetSent); EXPECT_TRUE(stream->retransmissionBuffer.empty()); EXPECT_TRUE(stream->writeBuffer.empty()); EXPECT_FALSE(stream->writable()); diff --git a/quic/client/QuicClientTransport.cpp b/quic/client/QuicClientTransport.cpp index 1caa7df45..7b20610f9 100644 --- a/quic/client/QuicClientTransport.cpp +++ b/quic/client/QuicClientTransport.cpp @@ -280,7 +280,7 @@ void QuicClientTransport::processPacketData( for (auto& quicFrame : regularPacket.frames) { switch (quicFrame.type()) { - case QuicFrame::Type::ReadAckFrame_E: { + case QuicFrame::Type::ReadAckFrame: { VLOG(10) << "Client received ack frame in packet=" << packetNum << " " << *this; ReadAckFrame& ackFrame = *quicFrame.asReadAckFrame(); @@ -310,7 +310,7 @@ void QuicClientTransport::processPacketData( } } switch (packetFrame.type()) { - case QuicWriteFrame::Type::WriteAckFrame_E: { + case QuicWriteFrame::Type::WriteAckFrame: { const WriteAckFrame& frame = *packetFrame.asWriteAckFrame(); DCHECK(!frame.ackBlocks.empty()); VLOG(4) << "Client received ack for largestAcked=" @@ -318,7 +318,7 @@ void QuicClientTransport::processPacketData( commonAckVisitorForAckFrame(ackState, frame); break; } - case QuicWriteFrame::Type::RstStreamFrame_E: { + case QuicWriteFrame::Type::RstStreamFrame: { const RstStreamFrame& frame = *packetFrame.asRstStreamFrame(); VLOG(4) << "Client received ack for reset frame stream=" << frame.streamId << " " << *this; @@ -329,7 +329,7 @@ void QuicClientTransport::processPacketData( } break; } - case QuicWriteFrame::Type::WriteStreamFrame_E: { + case QuicWriteFrame::Type::WriteStreamFrame: { const WriteStreamFrame& frame = *packetFrame.asWriteStreamFrame(); @@ -345,7 +345,7 @@ void QuicClientTransport::processPacketData( } break; } - case QuicWriteFrame::Type::WriteCryptoFrame_E: { + case QuicWriteFrame::Type::WriteCryptoFrame: { const WriteCryptoFrame& frame = *packetFrame.asWriteCryptoFrame(); auto cryptoStream = getCryptoStream( @@ -356,10 +356,10 @@ void QuicClientTransport::processPacketData( *cryptoStream, frame.offset, frame.len); break; } - case QuicWriteFrame::Type::PingFrame_E: + case QuicWriteFrame::Type::PingFrame: conn_->pendingEvents.cancelPingTimeout = true; break; - case QuicWriteFrame::Type::QuicSimpleFrame_E: + case QuicWriteFrame::Type::QuicSimpleFrame: default: // ignore other frames. break; @@ -369,7 +369,7 @@ void QuicClientTransport::processPacketData( receiveTimePoint); break; } - case QuicFrame::Type::RstStreamFrame_E: { + case QuicFrame::Type::RstStreamFrame: { RstStreamFrame& frame = *quicFrame.asRstStreamFrame(); VLOG(10) << "Client received reset stream=" << frame.streamId << " " << *this; @@ -382,7 +382,7 @@ void QuicClientTransport::processPacketData( receiveRstStreamSMHandler(*stream, std::move(frame)); break; } - case QuicFrame::Type::ReadCryptoFrame_E: { + case QuicFrame::Type::ReadCryptoFrame: { pktHasRetransmittableData = true; pktHasCryptoData = true; ReadCryptoFrame& cryptoFrame = *quicFrame.asReadCryptoFrame(); @@ -395,7 +395,7 @@ void QuicClientTransport::processPacketData( std::move(cryptoFrame.data), cryptoFrame.offset, false)); break; } - case QuicFrame::Type::ReadStreamFrame_E: { + case QuicFrame::Type::ReadStreamFrame: { ReadStreamFrame& frame = *quicFrame.asReadStreamFrame(); VLOG(10) << "Client received stream data for stream=" << frame.streamId << " offset=" << frame.offset @@ -412,7 +412,7 @@ void QuicClientTransport::processPacketData( receiveReadStreamFrameSMHandler(*stream, std::move(frame)); break; } - case QuicFrame::Type::MaxDataFrame_E: { + case QuicFrame::Type::MaxDataFrame: { MaxDataFrame& connWindowUpdate = *quicFrame.asMaxDataFrame(); VLOG(10) << "Client received max data offset=" << connWindowUpdate.maximumData << " " << *this; @@ -420,7 +420,7 @@ void QuicClientTransport::processPacketData( handleConnWindowUpdate(*conn_, connWindowUpdate, packetNum); break; } - case QuicFrame::Type::MaxStreamDataFrame_E: { + case QuicFrame::Type::MaxStreamDataFrame: { MaxStreamDataFrame& streamWindowUpdate = *quicFrame.asMaxStreamDataFrame(); VLOG(10) << "Client received max stream data stream=" @@ -441,13 +441,13 @@ void QuicClientTransport::processPacketData( } break; } - case QuicFrame::Type::DataBlockedFrame_E: { + case QuicFrame::Type::DataBlockedFrame: { VLOG(10) << "Client received blocked " << *this; pktHasRetransmittableData = true; handleConnBlocked(*conn_); break; } - case QuicFrame::Type::StreamDataBlockedFrame_E: { + case QuicFrame::Type::StreamDataBlockedFrame: { // peer wishes to send data, but is unable to due to stream-level flow // control StreamDataBlockedFrame& blocked = *quicFrame.asStreamDataBlockedFrame(); @@ -460,7 +460,7 @@ void QuicClientTransport::processPacketData( } break; } - case QuicFrame::Type::StreamsBlockedFrame_E: { + case QuicFrame::Type::StreamsBlockedFrame: { // peer wishes to open a stream, but is unable to due to the maximum // stream limit set by us StreamsBlockedFrame& blocked = *quicFrame.asStreamsBlockedFrame(); @@ -469,7 +469,7 @@ void QuicClientTransport::processPacketData( // TODO implement handler for it break; } - case QuicFrame::Type::ConnectionCloseFrame_E: { + case QuicFrame::Type::ConnectionCloseFrame: { ConnectionCloseFrame& connFrame = *quicFrame.asConnectionCloseFrame(); auto errMsg = folly::to( "Client closed by peer reason=", connFrame.reasonPhrase); @@ -486,13 +486,13 @@ void QuicClientTransport::processPacketData( "Peer closed", TransportErrorCode::NO_ERROR); break; } - case QuicFrame::Type::PingFrame_E: + case QuicFrame::Type::PingFrame: // Ping isn't retransmittable. But we would like to ack them early. pktHasRetransmittableData = true; break; - case QuicFrame::Type::PaddingFrame_E: + case QuicFrame::Type::PaddingFrame: break; - case QuicFrame::Type::QuicSimpleFrame_E: { + case QuicFrame::Type::QuicSimpleFrame: { QuicSimpleFrame& simpleFrame = *quicFrame.asQuicSimpleFrame(); pktHasRetransmittableData = true; updateSimpleFrameOnPacketReceived( diff --git a/quic/codec/QuicPacketRebuilder.cpp b/quic/codec/QuicPacketRebuilder.cpp index ca17c164e..63f1d92f5 100644 --- a/quic/codec/QuicPacketRebuilder.cpp +++ b/quic/codec/QuicPacketRebuilder.cpp @@ -58,7 +58,7 @@ folly::Optional PacketRebuilder::rebuildFromPacket( bool lastFrame = iter == packet.packet.frames.cend() - 1; const QuicWriteFrame& frame = *iter; switch (frame.type()) { - case QuicWriteFrame::Type::WriteAckFrame_E: { + case QuicWriteFrame::Type::WriteAckFrame: { const WriteAckFrame& ackFrame = *frame.asWriteAckFrame(); auto& packetHeader = builder_.getPacketHeader(); uint64_t ackDelayExponent = @@ -74,7 +74,7 @@ folly::Optional PacketRebuilder::rebuildFromPacket( writeSuccess = ackWriteResult.has_value(); break; } - case QuicWriteFrame::Type::WriteStreamFrame_E: { + case QuicWriteFrame::Type::WriteStreamFrame: { const WriteStreamFrame& streamFrame = *frame.asWriteStreamFrame(); auto stream = conn_.streamManager->getStream(streamFrame.streamId); if (stream && retransmittable(*stream)) { @@ -110,7 +110,7 @@ folly::Optional PacketRebuilder::rebuildFromPacket( writeSuccess = true; break; } - case QuicWriteFrame::Type::WriteCryptoFrame_E: { + case QuicWriteFrame::Type::WriteCryptoFrame: { const WriteCryptoFrame& cryptoFrame = *frame.asWriteCryptoFrame(); auto stream = getCryptoStream(*conn_.cryptoState, encryptionLevel); auto buf = cloneCryptoRetransmissionBuffer(cryptoFrame, *stream); @@ -129,7 +129,7 @@ folly::Optional PacketRebuilder::rebuildFromPacket( writeSuccess = ret; break; } - case QuicWriteFrame::Type::MaxDataFrame_E: { + case QuicWriteFrame::Type::MaxDataFrame: { shouldWriteWindowUpdate = true; auto ret = 0 != writeFrame(generateMaxDataFrame(conn_), builder_); windowUpdateWritten |= ret; @@ -137,7 +137,7 @@ folly::Optional PacketRebuilder::rebuildFromPacket( writeSuccess = true; break; } - case QuicWriteFrame::Type::MaxStreamDataFrame_E: { + case QuicWriteFrame::Type::MaxStreamDataFrame: { const MaxStreamDataFrame& maxStreamDataFrame = *frame.asMaxStreamDataFrame(); auto stream = @@ -154,17 +154,17 @@ folly::Optional PacketRebuilder::rebuildFromPacket( writeSuccess = true; break; } - case QuicWriteFrame::Type::PaddingFrame_E: { + case QuicWriteFrame::Type::PaddingFrame: { const PaddingFrame& paddingFrame = *frame.asPaddingFrame(); writeSuccess = writeFrame(paddingFrame, builder_) != 0; break; } - case QuicWriteFrame::Type::PingFrame_E: { + case QuicWriteFrame::Type::PingFrame: { const PingFrame& pingFrame = *frame.asPingFrame(); writeSuccess = writeFrame(pingFrame, builder_) != 0; break; } - case QuicWriteFrame::Type::QuicSimpleFrame_E: { + case QuicWriteFrame::Type::QuicSimpleFrame: { const QuicSimpleFrame& simpleFrame = *frame.asQuicSimpleFrame(); auto updatedSimpleFrame = updateSimpleFrameOnPacketClone(conn_, simpleFrame); diff --git a/quic/codec/QuicPacketRebuilder.h b/quic/codec/QuicPacketRebuilder.h index 5d86953f3..b4b01603e 100644 --- a/quic/codec/QuicPacketRebuilder.h +++ b/quic/codec/QuicPacketRebuilder.h @@ -43,7 +43,7 @@ class PacketRebuilder { PacketEvent cloneOutstandingPacket(OutstandingPacket& packet); bool retransmittable(const QuicStreamState& stream) const { - return stream.sendState == StreamSendState::Open_E; + return stream.sendState == StreamSendState::Open; } const BufQueue* cloneCryptoRetransmissionBuffer( diff --git a/quic/codec/QuicWriteCodec.cpp b/quic/codec/QuicWriteCodec.cpp index d5bdac9f3..e466d98a1 100644 --- a/quic/codec/QuicWriteCodec.cpp +++ b/quic/codec/QuicWriteCodec.cpp @@ -328,7 +328,7 @@ size_t writeSimpleFrame( uint64_t spaceLeft = builder.remainingSpaceInPkt(); switch (frame.type()) { - case QuicSimpleFrame::Type::StopSendingFrame_E: { + case QuicSimpleFrame::Type::StopSendingFrame: { const StopSendingFrame& stopSendingFrame = *frame.asStopSendingFrame(); QuicInteger intFrameType(static_cast(FrameType::STOP_SENDING)); QuicInteger streamId(stopSendingFrame.streamId); @@ -346,7 +346,7 @@ size_t writeSimpleFrame( // no space left in packet return size_t(0); } - case QuicSimpleFrame::Type::MinStreamDataFrame_E: { + case QuicSimpleFrame::Type::MinStreamDataFrame: { const MinStreamDataFrame& minStreamDataFrame = *frame.asMinStreamDataFrame(); QuicInteger streamId(minStreamDataFrame.streamId); @@ -367,7 +367,7 @@ size_t writeSimpleFrame( // no space left in packet return size_t(0); } - case QuicSimpleFrame::Type::ExpiredStreamDataFrame_E: { + case QuicSimpleFrame::Type::ExpiredStreamDataFrame: { const ExpiredStreamDataFrame& expiredStreamDataFrame = *frame.asExpiredStreamDataFrame(); QuicInteger frameType( @@ -387,7 +387,7 @@ size_t writeSimpleFrame( // no space left in packet return size_t(0); } - case QuicSimpleFrame::Type::PathChallengeFrame_E: { + case QuicSimpleFrame::Type::PathChallengeFrame: { const PathChallengeFrame& pathChallengeFrame = *frame.asPathChallengeFrame(); QuicInteger frameType(static_cast(FrameType::PATH_CHALLENGE)); @@ -402,7 +402,7 @@ size_t writeSimpleFrame( // no space left in packet return size_t(0); } - case QuicSimpleFrame::Type::PathResponseFrame_E: { + case QuicSimpleFrame::Type::PathResponseFrame: { const PathResponseFrame& pathResponseFrame = *frame.asPathResponseFrame(); QuicInteger frameType(static_cast(FrameType::PATH_RESPONSE)); auto pathResponseFrameSize = @@ -416,7 +416,7 @@ size_t writeSimpleFrame( // no space left in packet return size_t(0); } - case QuicSimpleFrame::Type::NewConnectionIdFrame_E: { + case QuicSimpleFrame::Type::NewConnectionIdFrame: { const NewConnectionIdFrame& newConnectionIdFrame = *frame.asNewConnectionIdFrame(); QuicInteger frameType(static_cast(FrameType::NEW_CONNECTION_ID)); @@ -444,7 +444,7 @@ size_t writeSimpleFrame( // no space left in packet return size_t(0); } - case QuicSimpleFrame::Type::MaxStreamsFrame_E: { + case QuicSimpleFrame::Type::MaxStreamsFrame: { const MaxStreamsFrame& maxStreamsFrame = *frame.asMaxStreamsFrame(); auto frameType = maxStreamsFrame.isForBidirectionalStream() ? FrameType::MAX_STREAMS_BIDI @@ -460,7 +460,7 @@ size_t writeSimpleFrame( } return size_t(0); } - case QuicSimpleFrame::Type::RetireConnectionIdFrame_E: { + case QuicSimpleFrame::Type::RetireConnectionIdFrame: { const RetireConnectionIdFrame& retireConnectionIdFrame = *frame.asRetireConnectionIdFrame(); QuicInteger frameType( @@ -477,7 +477,7 @@ size_t writeSimpleFrame( // no space left in packet return size_t(0); } - case QuicSimpleFrame::Type::HandshakeDoneFrame_E: { + case QuicSimpleFrame::Type::HandshakeDoneFrame: { const HandshakeDoneFrame& handshakeDoneFrame = *frame.asHandshakeDoneFrame(); CHECK(builder.getPacketHeader().asShort()); @@ -490,7 +490,7 @@ size_t writeSimpleFrame( // no space left in packet return size_t(0); } - case QuicSimpleFrame::Type::KnobFrame_E: { + case QuicSimpleFrame::Type::KnobFrame: { const KnobFrame& knobFrame = *frame.asKnobFrame(); QuicInteger intFrameType(static_cast(FrameType::KNOB)); QuicInteger intKnobSpace(knobFrame.knobSpace); @@ -520,7 +520,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { uint64_t spaceLeft = builder.remainingSpaceInPkt(); switch (frame.type()) { - case QuicWriteFrame::Type::PaddingFrame_E: { + case QuicWriteFrame::Type::PaddingFrame: { PaddingFrame& paddingFrame = *frame.asPaddingFrame(); QuicInteger intFrameType(static_cast(FrameType::PADDING)); if (packetSpaceCheck(spaceLeft, intFrameType.getSize())) { @@ -530,7 +530,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { } return size_t(0); } - case QuicWriteFrame::Type::RstStreamFrame_E: { + case QuicWriteFrame::Type::RstStreamFrame: { RstStreamFrame& rstStreamFrame = *frame.asRstStreamFrame(); QuicInteger intFrameType(static_cast(FrameType::RST_STREAM)); QuicInteger streamId(rstStreamFrame.streamId); @@ -550,7 +550,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { // no space left in packet return size_t(0); } - case QuicWriteFrame::Type::MaxDataFrame_E: { + case QuicWriteFrame::Type::MaxDataFrame: { MaxDataFrame& maxDataFrame = *frame.asMaxDataFrame(); QuicInteger intFrameType(static_cast(FrameType::MAX_DATA)); QuicInteger maximumData(maxDataFrame.maximumData); @@ -564,7 +564,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { // no space left in packet return size_t(0); } - case QuicWriteFrame::Type::MaxStreamDataFrame_E: { + case QuicWriteFrame::Type::MaxStreamDataFrame: { MaxStreamDataFrame& maxStreamDataFrame = *frame.asMaxStreamDataFrame(); QuicInteger intFrameType( static_cast(FrameType::MAX_STREAM_DATA)); @@ -582,7 +582,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { // no space left in packet return size_t(0); } - case QuicWriteFrame::Type::DataBlockedFrame_E: { + case QuicWriteFrame::Type::DataBlockedFrame: { DataBlockedFrame& blockedFrame = *frame.asDataBlockedFrame(); QuicInteger intFrameType(static_cast(FrameType::DATA_BLOCKED)); QuicInteger dataLimit(blockedFrame.dataLimit); @@ -596,7 +596,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { // no space left in packet return size_t(0); } - case QuicWriteFrame::Type::StreamDataBlockedFrame_E: { + case QuicWriteFrame::Type::StreamDataBlockedFrame: { StreamDataBlockedFrame& streamBlockedFrame = *frame.asStreamDataBlockedFrame(); QuicInteger intFrameType( @@ -615,7 +615,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { // no space left in packet return size_t(0); } - case QuicWriteFrame::Type::StreamsBlockedFrame_E: { + case QuicWriteFrame::Type::StreamsBlockedFrame: { StreamsBlockedFrame& streamsBlockedFrame = *frame.asStreamsBlockedFrame(); auto frameType = streamsBlockedFrame.isForBidirectionalStream() ? FrameType::STREAMS_BLOCKED_BIDI @@ -632,7 +632,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { // no space left in packet return size_t(0); } - case QuicWriteFrame::Type::ConnectionCloseFrame_E: { + case QuicWriteFrame::Type::ConnectionCloseFrame: { ConnectionCloseFrame& connectionCloseFrame = *frame.asConnectionCloseFrame(); // Need to distinguish between CONNECTION_CLOSE & CONNECTINO_CLOSE_APP_ERR @@ -677,7 +677,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { // no space left in packet return size_t(0); } - case QuicWriteFrame::Type::PingFrame_E: { + case QuicWriteFrame::Type::PingFrame: { const PingFrame& pingFrame = *frame.asPingFrame(); QuicInteger intFrameType(static_cast(FrameType::PING)); if (packetSpaceCheck(spaceLeft, intFrameType.getSize())) { @@ -688,7 +688,7 @@ size_t writeFrame(QuicWriteFrame&& frame, PacketBuilderInterface& builder) { // no space left in packet return size_t(0); } - case QuicWriteFrame::Type::QuicSimpleFrame_E: { + case QuicWriteFrame::Type::QuicSimpleFrame: { return writeSimpleFrame(std::move(*frame.asQuicSimpleFrame()), builder); } default: { diff --git a/quic/codec/test/QuicPacketRebuilderTest.cpp b/quic/codec/test/QuicPacketRebuilderTest.cpp index 896a7b86c..adeedbda9 100644 --- a/quic/codec/test/QuicPacketRebuilderTest.cpp +++ b/quic/codec/test/QuicPacketRebuilderTest.cpp @@ -129,7 +129,7 @@ TEST_F(QuicPacketRebuilderTest, RebuildPacket) { stream->flowControlState.advertisedMaxOffset); for (const auto& frame : packet2.packet.frames) { switch (frame.type()) { - case QuicWriteFrame::Type::ConnectionCloseFrame_E: { + case QuicWriteFrame::Type::ConnectionCloseFrame: { const ConnectionCloseFrame& closeFrame = *frame.asConnectionCloseFrame(); const TransportErrorCode* transportErrorCode = @@ -140,13 +140,13 @@ TEST_F(QuicPacketRebuilderTest, RebuildPacket) { EXPECT_EQ(FrameType::ACK, closeFrame.closingFrameType); break; } - case QuicWriteFrame::Type::PingFrame_E: + case QuicWriteFrame::Type::PingFrame: EXPECT_NE(frame.asPingFrame(), nullptr); break; - case QuicWriteFrame::Type::QuicSimpleFrame_E: { + case QuicWriteFrame::Type::QuicSimpleFrame: { const QuicSimpleFrame& simpleFrame = *frame.asQuicSimpleFrame(); switch (simpleFrame.type()) { - case QuicSimpleFrame::Type::MaxStreamsFrame_E: { + case QuicSimpleFrame::Type::MaxStreamsFrame: { const MaxStreamsFrame* maxStreamFrame = simpleFrame.asMaxStreamsFrame(); EXPECT_NE(maxStreamFrame, nullptr); @@ -158,13 +158,13 @@ TEST_F(QuicPacketRebuilderTest, RebuildPacket) { } break; } - case QuicWriteFrame::Type::WriteAckFrame_E: { + case QuicWriteFrame::Type::WriteAckFrame: { const WriteAckFrame& ack = *frame.asWriteAckFrame(); EXPECT_EQ(Interval(10, 100), ack.ackBlocks.back()); EXPECT_EQ(Interval(200, 1000), ack.ackBlocks.front()); break; } - case QuicWriteFrame::Type::WriteStreamFrame_E: { + case QuicWriteFrame::Type::WriteStreamFrame: { const WriteStreamFrame& streamFrame = *frame.asWriteStreamFrame(); EXPECT_EQ(streamId, streamFrame.streamId); EXPECT_EQ(0, streamFrame.offset); @@ -172,18 +172,18 @@ TEST_F(QuicPacketRebuilderTest, RebuildPacket) { EXPECT_EQ(true, streamFrame.fin); break; } - case QuicWriteFrame::Type::WriteCryptoFrame_E: { + case QuicWriteFrame::Type::WriteCryptoFrame: { const WriteCryptoFrame& cryptoFrame = *frame.asWriteCryptoFrame(); EXPECT_EQ(cryptoFrame.offset, cryptoOffset); EXPECT_EQ(cryptoFrame.len, cryptoBuf->computeChainDataLength()); break; } - case QuicWriteFrame::Type::MaxDataFrame_E: { + case QuicWriteFrame::Type::MaxDataFrame: { const MaxDataFrame& maxData = *frame.asMaxDataFrame(); EXPECT_EQ(expectedConnFlowControlValue, maxData.maximumData); break; } - case QuicWriteFrame::Type::MaxStreamDataFrame_E: { + case QuicWriteFrame::Type::MaxStreamDataFrame: { const MaxStreamDataFrame& maxStreamData = *frame.asMaxStreamDataFrame(); EXPECT_EQ(streamId, maxStreamData.streamId); EXPECT_EQ(expectedStreamFlowControlValue, maxStreamData.maximumData); diff --git a/quic/common/Variant.h b/quic/common/Variant.h index d228507cf..738f87c6c 100644 --- a/quic/common/Variant.h +++ b/quic/common/Variant.h @@ -12,51 +12,51 @@ namespace quic { #define UNION_TYPE(X, ...) X X##_; -#define ENUM_TYPES(X, ...) X##_E, +#define ENUM_TYPES(X, ...) X, -#define UNION_ACCESSOR(X, ...) \ - X* as##X() { \ - if (type_ == Type::X##_E) { \ - return &X##_; \ - } \ - return nullptr; \ +#define UNION_ACCESSOR(X, ...) \ + X* as##X() { \ + if (type_ == Type::X) { \ + return &X##_; \ + } \ + return nullptr; \ } #define CONST_UNION_ACCESSOR(X, ...) \ const X* as##X() const { \ - if (type_ == Type::X##_E) { \ + if (type_ == Type::X) { \ return &X##_; \ } \ return nullptr; \ } -#define UNION_CTORS(X, NAME) \ - NAME(X&& x) : type_(Type::X##_E) { \ - new (&X##_) X(std::move(x)); \ +#define UNION_CTORS(X, NAME) \ + NAME(X&& x) : type_(Type::X) { \ + new (&X##_) X(std::move(x)); \ } -#define UNION_COPY_CTORS(X, NAME) \ - NAME(const X& x) : type_(Type::X##_E) { \ - new (&X##_) X(x); \ +#define UNION_COPY_CTORS(X, NAME) \ + NAME(const X& x) : type_(Type::X) { \ + new (&X##_) X(x); \ } #define UNION_MOVE_CASES(X, other) \ - case Type::X##_E: \ + case Type::X: \ new (&X##_) X(std::move(other.X##_)); \ break; #define UNION_COPY_CASES(X, other) \ - case Type::X##_E: \ + case Type::X: \ new (&X##_) X(other.X##_); \ break; #define DESTRUCTOR_CASES(X, ...) \ - case Type::X##_E: \ + case Type::X: \ X##_.~X(); \ break; #define UNION_EQUALITY_CASES(X, other) \ - case Type::X##_E: \ + case Type::X: \ return X##_ == *other.as##X(); #define DECLARE_VARIANT_TYPE(NAME, X) \ diff --git a/quic/common/test/TestUtils.cpp b/quic/common/test/TestUtils.cpp index de438f4b7..e43b4c4fa 100644 --- a/quic/common/test/TestUtils.cpp +++ b/quic/common/test/TestUtils.cpp @@ -709,37 +709,35 @@ std::vector getQLogEventIndices( bool matchError( std::pair> errorCode, LocalErrorCode error) { - return errorCode.first.type() == QuicErrorCode::Type::LocalErrorCode_E && + return errorCode.first.type() == QuicErrorCode::Type::LocalErrorCode && *errorCode.first.asLocalErrorCode() == error; } bool matchError( std::pair> errorCode, TransportErrorCode error) { - return errorCode.first.type() == QuicErrorCode::Type::TransportErrorCode_E && + return errorCode.first.type() == QuicErrorCode::Type::TransportErrorCode && *errorCode.first.asTransportErrorCode() == error; } bool matchError( std::pair> errorCode, ApplicationErrorCode error) { - return errorCode.first.type() == - QuicErrorCode::Type::ApplicationErrorCode_E && + return errorCode.first.type() == QuicErrorCode::Type::ApplicationErrorCode && *errorCode.first.asApplicationErrorCode() == error; } bool matchError( std::pair errorCode, ApplicationErrorCode error) { - return errorCode.first.type() == - QuicErrorCode::Type::ApplicationErrorCode_E && + return errorCode.first.type() == QuicErrorCode::Type::ApplicationErrorCode && *errorCode.first.asApplicationErrorCode() == error; } bool matchError( std::pair errorCode, TransportErrorCode error) { - return errorCode.first.type() == QuicErrorCode::Type::TransportErrorCode_E && + return errorCode.first.type() == QuicErrorCode::Type::TransportErrorCode && *errorCode.first.asTransportErrorCode() == error; } diff --git a/quic/common/test/VariantTest.cpp b/quic/common/test/VariantTest.cpp index a702cb69f..e9f6ab14c 100644 --- a/quic/common/test/VariantTest.cpp +++ b/quic/common/test/VariantTest.cpp @@ -86,9 +86,9 @@ TEST(Variant, TestCreateVariant) { TestVariant variantB{B()}; TestVariant variantC{C()}; - EXPECT_EQ(variantA.type(), TestVariant::Type::A_E); - EXPECT_EQ(variantB.type(), TestVariant::Type::B_E); - EXPECT_EQ(variantC.type(), TestVariant::Type::C_E); + EXPECT_EQ(variantA.type(), TestVariant::Type::A); + EXPECT_EQ(variantB.type(), TestVariant::Type::B); + EXPECT_EQ(variantC.type(), TestVariant::Type::C); EXPECT_NE(variantA.asA(), nullptr); EXPECT_NE(variantB.asB(), nullptr); diff --git a/quic/fizz/client/test/QuicClientTransportTest.cpp b/quic/fizz/client/test/QuicClientTransportTest.cpp index 7397d3295..c893a91d4 100644 --- a/quic/fizz/client/test/QuicClientTransportTest.cpp +++ b/quic/fizz/client/test/QuicClientTransportTest.cpp @@ -3497,7 +3497,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithStreamPending) { EXPECT_CALL(readCb, readError(streamId, _)); client->closeGracefully(); EXPECT_FALSE(verifyFramePresent( - socketWrites, *serverReadCodec, QuicFrame::Type::ConnectionCloseFrame_E)); + socketWrites, *serverReadCodec, QuicFrame::Type::ConnectionCloseFrame)); // close the stream auto packet = packetToBuf(createStreamPacket( @@ -3513,7 +3513,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithStreamPending) { socketWrites.clear(); deliverData(packet->coalesce()); EXPECT_TRUE(verifyFramePresent( - socketWrites, *serverReadCodec, QuicFrame::Type::ConnectionCloseFrame_E)); + socketWrites, *serverReadCodec, QuicFrame::Type::ConnectionCloseFrame)); std::vector indices = getQLogEventIndices(QLogEventType::ConnectionClose, qLogger); @@ -3586,7 +3586,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithNoStreamPending) { EXPECT_TRUE(verifyFramePresent( socketWrites, *makeEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } class QuicClientTransportAfterStartTestClose @@ -3618,7 +3618,7 @@ TEST_P( EXPECT_TRUE(verifyFramePresent( socketWrites, *makeHandshakeCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); std::vector indices = getQLogEventIndices(QLogEventType::ConnectionClose, qLogger); @@ -3636,7 +3636,7 @@ TEST_P( EXPECT_TRUE(verifyFramePresent( socketWrites, *makeHandshakeCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); std::vector indices = getQLogEventIndices(QLogEventType::ConnectionClose, qLogger); // expecting that connection close called once @@ -3785,13 +3785,13 @@ TEST_P(QuicClientTransportAfterStartTestClose, CloseConnectionWithError) { EXPECT_TRUE(verifyFramePresent( socketWrites, *makeHandshakeCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } else { client->close(folly::none); EXPECT_TRUE(verifyFramePresent( socketWrites, *makeHandshakeCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } } @@ -3999,9 +3999,9 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimeoutExpired) { auto serverCodec = makeEncryptedCodec(); // We expect a conn close in a cleartext packet. EXPECT_FALSE(verifyFramePresent( - socketWrites, *serverCodec, QuicFrame::Type::ConnectionCloseFrame_E)); + socketWrites, *serverCodec, QuicFrame::Type::ConnectionCloseFrame)); EXPECT_FALSE(verifyFramePresent( - socketWrites, *serverCodec, QuicFrame::Type::ConnectionCloseFrame_E)); + socketWrites, *serverCodec, QuicFrame::Type::ConnectionCloseFrame)); EXPECT_TRUE(socketWrites.empty()); } @@ -4028,7 +4028,7 @@ TEST_F(QuicClientTransportAfterStartTest, RecvDataAfterIdleTimeout) { EXPECT_TRUE(verifyFramePresent( socketWrites, *makeEncryptedCodec(true), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); std::vector indices = getQLogEventIndices(QLogEventType::PacketDrop, qLogger); EXPECT_EQ(indices.size(), 1); @@ -4964,7 +4964,7 @@ TEST_F(QuicClientTransportAfterStartTest, ReceiveConnectionClose) { EXPECT_TRUE(verifyFramePresent( socketWrites, *makeHandshakeCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } TEST_F(QuicClientTransportAfterStartTest, ReceiveApplicationClose) { @@ -4996,7 +4996,7 @@ TEST_F(QuicClientTransportAfterStartTest, ReceiveApplicationClose) { EXPECT_TRUE(verifyFramePresent( socketWrites, *makeHandshakeCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); std::vector indices = getQLogEventIndices(QLogEventType::TransportStateUpdate, qLogger); @@ -5033,7 +5033,7 @@ TEST_F(QuicClientTransportAfterStartTest, ReceiveApplicationCloseNoError) { EXPECT_TRUE(verifyFramePresent( socketWrites, *makeHandshakeCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } TEST_F(QuicClientTransportAfterStartTest, DestroyWithoutClosing) { diff --git a/quic/flowcontrol/test/QuicFlowControlTest.cpp b/quic/flowcontrol/test/QuicFlowControlTest.cpp index 719da13b2..21684c1cb 100644 --- a/quic/flowcontrol/test/QuicFlowControlTest.cpp +++ b/quic/flowcontrol/test/QuicFlowControlTest.cpp @@ -234,8 +234,8 @@ TEST_F(QuicFlowControlTest, DontSendStreamWindowUpdateTwice) { TEST_F(QuicFlowControlTest, DontSendStreamWindowUpdateOnRemoteHalfClosed) { StreamId id = 3; QuicStreamState stream(id, conn_); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Closed; // Should not send window update maybeSendStreamWindowUpdate(stream, Clock::now()); EXPECT_FALSE(conn_.streamManager->pendingWindowUpdate(stream.id)); @@ -423,8 +423,8 @@ TEST_F(QuicFlowControlTest, LostStreamWindowUpdateHalfClosedRemote) { stream.currentReadOffset = 300; stream.flowControlState.windowSize = 500; stream.flowControlState.advertisedMaxOffset = 400; - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Closed; // Should not send window update onStreamWindowUpdateLost(stream); diff --git a/quic/logging/BaseQLogger.cpp b/quic/logging/BaseQLogger.cpp index 2560e60b2..2459cf3c4 100644 --- a/quic/logging/BaseQLogger.cpp +++ b/quic/logging/BaseQLogger.cpp @@ -7,53 +7,53 @@ void addQuicSimpleFrameToEvent( quic::QLogPacketEvent* event, const quic::QuicSimpleFrame& simpleFrame) { switch (simpleFrame.type()) { - case quic::QuicSimpleFrame::Type::StopSendingFrame_E: { + case quic::QuicSimpleFrame::Type::StopSendingFrame: { const quic::StopSendingFrame& frame = *simpleFrame.asStopSendingFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.errorCode)); break; } - case quic::QuicSimpleFrame::Type::MinStreamDataFrame_E: { + case quic::QuicSimpleFrame::Type::MinStreamDataFrame: { const quic::MinStreamDataFrame& frame = *simpleFrame.asMinStreamDataFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.maximumData, frame.minimumStreamOffset)); break; } - case quic::QuicSimpleFrame::Type::ExpiredStreamDataFrame_E: { + case quic::QuicSimpleFrame::Type::ExpiredStreamDataFrame: { const quic::ExpiredStreamDataFrame& frame = *simpleFrame.asExpiredStreamDataFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.minimumStreamOffset)); break; } - case quic::QuicSimpleFrame::Type::PathChallengeFrame_E: { + case quic::QuicSimpleFrame::Type::PathChallengeFrame: { const quic::PathChallengeFrame& frame = *simpleFrame.asPathChallengeFrame(); event->frames.push_back( std::make_unique(frame.pathData)); break; } - case quic::QuicSimpleFrame::Type::PathResponseFrame_E: { + case quic::QuicSimpleFrame::Type::PathResponseFrame: { const quic::PathResponseFrame& frame = *simpleFrame.asPathResponseFrame(); event->frames.push_back( std::make_unique(frame.pathData)); break; } - case quic::QuicSimpleFrame::Type::NewConnectionIdFrame_E: { + case quic::QuicSimpleFrame::Type::NewConnectionIdFrame: { const quic::NewConnectionIdFrame& frame = *simpleFrame.asNewConnectionIdFrame(); event->frames.push_back(std::make_unique( frame.sequenceNumber, frame.token)); break; } - case quic::QuicSimpleFrame::Type::MaxStreamsFrame_E: { + case quic::QuicSimpleFrame::Type::MaxStreamsFrame: { const quic::MaxStreamsFrame& frame = *simpleFrame.asMaxStreamsFrame(); event->frames.push_back(std::make_unique( frame.maxStreams, frame.isForBidirectional)); break; } - case quic::QuicSimpleFrame::Type::RetireConnectionIdFrame_E: { + case quic::QuicSimpleFrame::Type::RetireConnectionIdFrame: { const quic::RetireConnectionIdFrame& frame = *simpleFrame.asRetireConnectionIdFrame(); event->frames.push_back( @@ -61,11 +61,11 @@ void addQuicSimpleFrameToEvent( frame.sequenceNumber)); break; } - case quic::QuicSimpleFrame::Type::HandshakeDoneFrame_E: { + case quic::QuicSimpleFrame::Type::HandshakeDoneFrame: { event->frames.push_back(std::make_unique()); break; } - case quic::QuicSimpleFrame::Type::KnobFrame_E: { + case quic::QuicSimpleFrame::Type::KnobFrame: { const quic::KnobFrame& frame = *simpleFrame.asKnobFrame(); event->frames.push_back(std::make_unique( frame.knobSpace, frame.id, frame.blob->length())); @@ -101,83 +101,83 @@ std::unique_ptr BaseQLogger::createPacketEvent( // looping through the packet to store logs created from frames in the packet for (const auto& quicFrame : regularPacket.frames) { switch (quicFrame.type()) { - case QuicFrame::Type::PaddingFrame_E: { + case QuicFrame::Type::PaddingFrame: { ++numPaddingFrames; break; } - case QuicFrame::Type::RstStreamFrame_E: { + case QuicFrame::Type::RstStreamFrame: { const auto& frame = *quicFrame.asRstStreamFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.errorCode, frame.offset)); break; } - case QuicFrame::Type::ConnectionCloseFrame_E: { + case QuicFrame::Type::ConnectionCloseFrame: { const auto& frame = *quicFrame.asConnectionCloseFrame(); event->frames.push_back(std::make_unique( frame.errorCode, frame.reasonPhrase, frame.closingFrameType)); break; } - case QuicFrame::Type::MaxDataFrame_E: { + case QuicFrame::Type::MaxDataFrame: { const auto& frame = *quicFrame.asMaxDataFrame(); event->frames.push_back( std::make_unique(frame.maximumData)); break; } - case QuicFrame::Type::MaxStreamDataFrame_E: { + case QuicFrame::Type::MaxStreamDataFrame: { const auto& frame = *quicFrame.asMaxStreamDataFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.maximumData)); break; } - case QuicFrame::Type::DataBlockedFrame_E: { + case QuicFrame::Type::DataBlockedFrame: { const auto& frame = *quicFrame.asDataBlockedFrame(); event->frames.push_back( std::make_unique(frame.dataLimit)); break; } - case QuicFrame::Type::StreamDataBlockedFrame_E: { + case QuicFrame::Type::StreamDataBlockedFrame: { const auto& frame = *quicFrame.asStreamDataBlockedFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.dataLimit)); break; } - case QuicFrame::Type::StreamsBlockedFrame_E: { + case QuicFrame::Type::StreamsBlockedFrame: { const auto& frame = *quicFrame.asStreamsBlockedFrame(); event->frames.push_back(std::make_unique( frame.streamLimit, frame.isForBidirectional)); break; } - case QuicFrame::Type::ReadAckFrame_E: { + case QuicFrame::Type::ReadAckFrame: { const auto& frame = *quicFrame.asReadAckFrame(); event->frames.push_back( std::make_unique(frame.ackBlocks, frame.ackDelay)); break; } - case QuicFrame::Type::ReadStreamFrame_E: { + case QuicFrame::Type::ReadStreamFrame: { const auto& frame = *quicFrame.asReadStreamFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.offset, frame.data->length(), frame.fin)); break; } - case QuicFrame::Type::ReadCryptoFrame_E: { + case QuicFrame::Type::ReadCryptoFrame: { const auto& frame = *quicFrame.asReadCryptoFrame(); event->frames.push_back(std::make_unique( frame.offset, frame.data->length())); break; } - case QuicFrame::Type::ReadNewTokenFrame_E: { + case QuicFrame::Type::ReadNewTokenFrame: { event->frames.push_back(std::make_unique()); break; } - case QuicFrame::Type::PingFrame_E: + case QuicFrame::Type::PingFrame: event->frames.push_back(std::make_unique()); break; - case QuicFrame::Type::QuicSimpleFrame_E: { + case QuicFrame::Type::QuicSimpleFrame: { const auto& simpleFrame = *quicFrame.asQuicSimpleFrame(); addQuicSimpleFrameToEvent(event.get(), simpleFrame); break; } - case QuicFrame::Type::NoopFrame_E: { + case QuicFrame::Type::NoopFrame: { break; } } @@ -210,71 +210,71 @@ std::unique_ptr BaseQLogger::createPacketEvent( // looping through the packet to store logs created from frames in the packet for (const auto& quicFrame : writePacket.frames) { switch (quicFrame.type()) { - case QuicWriteFrame::Type::PaddingFrame_E: + case QuicWriteFrame::Type::PaddingFrame: ++numPaddingFrames; break; - case QuicWriteFrame::Type::RstStreamFrame_E: { + case QuicWriteFrame::Type::RstStreamFrame: { const RstStreamFrame& frame = *quicFrame.asRstStreamFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.errorCode, frame.offset)); break; } - case QuicWriteFrame::Type::ConnectionCloseFrame_E: { + case QuicWriteFrame::Type::ConnectionCloseFrame: { const ConnectionCloseFrame& frame = *quicFrame.asConnectionCloseFrame(); event->frames.push_back(std::make_unique( frame.errorCode, frame.reasonPhrase, frame.closingFrameType)); break; } - case QuicWriteFrame::Type::MaxDataFrame_E: { + case QuicWriteFrame::Type::MaxDataFrame: { const MaxDataFrame& frame = *quicFrame.asMaxDataFrame(); event->frames.push_back( std::make_unique(frame.maximumData)); break; } - case QuicWriteFrame::Type::MaxStreamDataFrame_E: { + case QuicWriteFrame::Type::MaxStreamDataFrame: { const MaxStreamDataFrame& frame = *quicFrame.asMaxStreamDataFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.maximumData)); break; } - case QuicWriteFrame::Type::StreamsBlockedFrame_E: { + case QuicWriteFrame::Type::StreamsBlockedFrame: { const StreamsBlockedFrame& frame = *quicFrame.asStreamsBlockedFrame(); event->frames.push_back(std::make_unique( frame.streamLimit, frame.isForBidirectional)); break; } - case QuicWriteFrame::Type::DataBlockedFrame_E: { + case QuicWriteFrame::Type::DataBlockedFrame: { const DataBlockedFrame& frame = *quicFrame.asDataBlockedFrame(); event->frames.push_back( std::make_unique(frame.dataLimit)); break; } - case QuicWriteFrame::Type::StreamDataBlockedFrame_E: { + case QuicWriteFrame::Type::StreamDataBlockedFrame: { const StreamDataBlockedFrame& frame = *quicFrame.asStreamDataBlockedFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.dataLimit)); break; } - case QuicWriteFrame::Type::WriteAckFrame_E: { + case QuicWriteFrame::Type::WriteAckFrame: { const WriteAckFrame& frame = *quicFrame.asWriteAckFrame(); event->frames.push_back(std::make_unique( frame.ackBlocks, frame.ackDelay)); break; } - case QuicWriteFrame::Type::WriteStreamFrame_E: { + case QuicWriteFrame::Type::WriteStreamFrame: { const WriteStreamFrame& frame = *quicFrame.asWriteStreamFrame(); event->frames.push_back(std::make_unique( frame.streamId, frame.offset, frame.len, frame.fin)); break; } - case QuicWriteFrame::Type::WriteCryptoFrame_E: { + case QuicWriteFrame::Type::WriteCryptoFrame: { const WriteCryptoFrame& frame = *quicFrame.asWriteCryptoFrame(); event->frames.push_back( std::make_unique(frame.offset, frame.len)); break; } - case QuicWriteFrame::Type::QuicSimpleFrame_E: { + case QuicWriteFrame::Type::QuicSimpleFrame: { const QuicSimpleFrame& simpleFrame = *quicFrame.asQuicSimpleFrame(); addQuicSimpleFrameToEvent(event.get(), simpleFrame); break; diff --git a/quic/loss/QuicLossFunctions.cpp b/quic/loss/QuicLossFunctions.cpp index 8ca79487e..b9d1b6096 100644 --- a/quic/loss/QuicLossFunctions.cpp +++ b/quic/loss/QuicLossFunctions.cpp @@ -67,7 +67,7 @@ void markPacketLoss( QUIC_STATS(conn.statsCallback, onPacketLoss); for (auto& packetFrame : packet.frames) { switch (packetFrame.type()) { - case QuicWriteFrame::Type::MaxStreamDataFrame_E: { + case QuicWriteFrame::Type::MaxStreamDataFrame: { MaxStreamDataFrame& frame = *packetFrame.asMaxStreamDataFrame(); // For all other frames, we process it if it's not from a clone // packet, or if the clone and its siblings have never been processed. @@ -82,20 +82,20 @@ void markPacketLoss( onStreamWindowUpdateLost(*stream); break; } - case QuicWriteFrame::Type::MaxDataFrame_E: { + case QuicWriteFrame::Type::MaxDataFrame: { onConnWindowUpdateLost(conn); break; } // For other frame types, we only process them if the packet is not a // processed clone. - case QuicWriteFrame::Type::DataBlockedFrame_E: { + case QuicWriteFrame::Type::DataBlockedFrame: { if (processed) { break; } onDataBlockedLost(conn); break; } - case QuicWriteFrame::Type::WriteStreamFrame_E: { + case QuicWriteFrame::Type::WriteStreamFrame: { WriteStreamFrame frame = *packetFrame.asWriteStreamFrame(); if (processed) { break; @@ -122,7 +122,7 @@ void markPacketLoss( conn.streamManager->updateLossStreams(*stream); break; } - case QuicWriteFrame::Type::WriteCryptoFrame_E: { + case QuicWriteFrame::Type::WriteCryptoFrame: { WriteCryptoFrame& frame = *packetFrame.asWriteCryptoFrame(); if (processed) { break; @@ -142,7 +142,7 @@ void markPacketLoss( cryptoStream->retransmissionBuffer.erase(bufferItr); break; } - case QuicWriteFrame::Type::RstStreamFrame_E: { + case QuicWriteFrame::Type::RstStreamFrame: { RstStreamFrame& frame = *packetFrame.asRstStreamFrame(); if (processed) { break; @@ -157,7 +157,7 @@ void markPacketLoss( conn.pendingEvents.resets.insert({frame.streamId, frame}); break; } - case QuicWriteFrame::Type::StreamDataBlockedFrame_E: { + case QuicWriteFrame::Type::StreamDataBlockedFrame: { StreamDataBlockedFrame& frame = *packetFrame.asStreamDataBlockedFrame(); if (processed) { break; @@ -170,7 +170,7 @@ void markPacketLoss( onBlockedLost(*stream); break; } - case QuicWriteFrame::Type::QuicSimpleFrame_E: { + case QuicWriteFrame::Type::QuicSimpleFrame: { QuicSimpleFrame& frame = *packetFrame.asQuicSimpleFrame(); if (processed) { break; diff --git a/quic/loss/test/QuicLossFunctionsTest.cpp b/quic/loss/test/QuicLossFunctionsTest.cpp index d53c06782..d8ae521d0 100644 --- a/quic/loss/test/QuicLossFunctionsTest.cpp +++ b/quic/loss/test/QuicLossFunctionsTest.cpp @@ -1594,13 +1594,13 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) { getLastOutstandingPacket(*conn, PacketNumberSpace::AppData) ->packet.frames) { switch (frame.type()) { - case QuicWriteFrame::Type::WriteStreamFrame_E: + case QuicWriteFrame::Type::WriteStreamFrame: streamDataCounter++; break; - case QuicWriteFrame::Type::MaxStreamDataFrame_E: + case QuicWriteFrame::Type::MaxStreamDataFrame: streamWindowUpdateCounter++; break; - case QuicWriteFrame::Type::MaxDataFrame_E: + case QuicWriteFrame::Type::MaxDataFrame: connWindowUpdateCounter++; break; default: diff --git a/quic/server/state/ServerStateMachine.cpp b/quic/server/state/ServerStateMachine.cpp index ac3befffc..58ef4c3be 100644 --- a/quic/server/state/ServerStateMachine.cpp +++ b/quic/server/state/ServerStateMachine.cpp @@ -855,7 +855,7 @@ void onServerReadDataFromOpen( // what we've already processed is difficult. for (auto& quicFrame : regularPacket.frames) { switch (quicFrame.type()) { - case QuicFrame::Type::ReadAckFrame_E: { + case QuicFrame::Type::ReadAckFrame: { VLOG(10) << "Server received ack frame packet=" << packetNum << " " << conn; isNonProbingPacket = true; @@ -868,7 +868,7 @@ void onServerReadDataFromOpen( const QuicWriteFrame& packetFrame, const ReadAckFrame&) { switch (packetFrame.type()) { - case QuicWriteFrame::Type::WriteStreamFrame_E: { + case QuicWriteFrame::Type::WriteStreamFrame: { const WriteStreamFrame& frame = *packetFrame.asWriteStreamFrame(); VLOG(4) @@ -882,7 +882,7 @@ void onServerReadDataFromOpen( } break; } - case QuicWriteFrame::Type::WriteCryptoFrame_E: { + case QuicWriteFrame::Type::WriteCryptoFrame: { const WriteCryptoFrame& frame = *packetFrame.asWriteCryptoFrame(); auto cryptoStream = @@ -891,7 +891,7 @@ void onServerReadDataFromOpen( *cryptoStream, frame.offset, frame.len); break; } - case QuicWriteFrame::Type::RstStreamFrame_E: { + case QuicWriteFrame::Type::RstStreamFrame: { const RstStreamFrame& frame = *packetFrame.asRstStreamFrame(); VLOG(4) << "Server received ack for reset stream=" @@ -902,7 +902,7 @@ void onServerReadDataFromOpen( } break; } - case QuicWriteFrame::Type::WriteAckFrame_E: { + case QuicWriteFrame::Type::WriteAckFrame: { const WriteAckFrame& frame = *packetFrame.asWriteAckFrame(); DCHECK(!frame.ackBlocks.empty()); VLOG(4) << "Server received ack for largestAcked=" @@ -910,12 +910,12 @@ void onServerReadDataFromOpen( commonAckVisitorForAckFrame(ackState, frame); break; } - case QuicWriteFrame::Type::PingFrame_E: + case QuicWriteFrame::Type::PingFrame: if (!packet.metadata.isD6DProbe) { conn.pendingEvents.cancelPingTimeout = true; } return; - case QuicWriteFrame::Type::QuicSimpleFrame_E: { + case QuicWriteFrame::Type::QuicSimpleFrame: { const QuicSimpleFrame& frame = *packetFrame.asQuicSimpleFrame(); // ACK of HandshakeDone is a server-specific behavior. @@ -936,7 +936,7 @@ void onServerReadDataFromOpen( readData.networkData.receiveTimePoint); break; } - case QuicFrame::Type::RstStreamFrame_E: { + case QuicFrame::Type::RstStreamFrame: { RstStreamFrame& frame = *quicFrame.asRstStreamFrame(); VLOG(10) << "Server received reset stream=" << frame.streamId << " " << conn; @@ -952,7 +952,7 @@ void onServerReadDataFromOpen( receiveRstStreamSMHandler(*stream, std::move(frame)); break; } - case QuicFrame::Type::ReadCryptoFrame_E: { + case QuicFrame::Type::ReadCryptoFrame: { pktHasRetransmittableData = true; pktHasCryptoData = true; isNonProbingPacket = true; @@ -970,7 +970,7 @@ void onServerReadDataFromOpen( std::move(cryptoFrame.data), cryptoFrame.offset, false)); break; } - case QuicFrame::Type::ReadStreamFrame_E: { + case QuicFrame::Type::ReadStreamFrame: { ReadStreamFrame& frame = *quicFrame.asReadStreamFrame(); VLOG(10) << "Server received stream data for stream=" << frame.streamId << ", offset=" << frame.offset @@ -986,7 +986,7 @@ void onServerReadDataFromOpen( } break; } - case QuicFrame::Type::MaxDataFrame_E: { + case QuicFrame::Type::MaxDataFrame: { MaxDataFrame& connWindowUpdate = *quicFrame.asMaxDataFrame(); VLOG(10) << "Server received max data offset=" << connWindowUpdate.maximumData << " " << conn; @@ -995,7 +995,7 @@ void onServerReadDataFromOpen( handleConnWindowUpdate(conn, connWindowUpdate, packetNum); break; } - case QuicFrame::Type::MaxStreamDataFrame_E: { + case QuicFrame::Type::MaxStreamDataFrame: { MaxStreamDataFrame& streamWindowUpdate = *quicFrame.asMaxStreamDataFrame(); VLOG(10) << "Server received max stream data stream=" @@ -1017,14 +1017,14 @@ void onServerReadDataFromOpen( } break; } - case QuicFrame::Type::DataBlockedFrame_E: { + case QuicFrame::Type::DataBlockedFrame: { VLOG(10) << "Server received blocked " << conn; pktHasRetransmittableData = true; isNonProbingPacket = true; handleConnBlocked(conn); break; } - case QuicFrame::Type::StreamDataBlockedFrame_E: { + case QuicFrame::Type::StreamDataBlockedFrame: { StreamDataBlockedFrame& blocked = *quicFrame.asStreamDataBlockedFrame(); VLOG(10) << "Server received blocked stream=" << blocked.streamId @@ -1037,7 +1037,7 @@ void onServerReadDataFromOpen( } break; } - case QuicFrame::Type::StreamsBlockedFrame_E: { + case QuicFrame::Type::StreamsBlockedFrame: { StreamsBlockedFrame& blocked = *quicFrame.asStreamsBlockedFrame(); // peer wishes to open a stream, but is unable to due to the maximum // stream limit set by us @@ -1047,7 +1047,7 @@ void onServerReadDataFromOpen( << blocked.streamLimit << ", " << conn; break; } - case QuicFrame::Type::ConnectionCloseFrame_E: { + case QuicFrame::Type::ConnectionCloseFrame: { isNonProbingPacket = true; ConnectionCloseFrame& connFrame = *quicFrame.asConnectionCloseFrame(); auto errMsg = folly::to( @@ -1068,15 +1068,15 @@ void onServerReadDataFromOpen( "Peer closed", TransportErrorCode::NO_ERROR); break; } - case QuicFrame::Type::PingFrame_E: + case QuicFrame::Type::PingFrame: isNonProbingPacket = true; // Ping isn't retransmittable data. But we would like to ack them // early. pktHasRetransmittableData = true; break; - case QuicFrame::Type::PaddingFrame_E: + case QuicFrame::Type::PaddingFrame: break; - case QuicFrame::Type::QuicSimpleFrame_E: { + case QuicFrame::Type::QuicSimpleFrame: { pktHasRetransmittableData = true; QuicSimpleFrame& simpleFrame = *quicFrame.asQuicSimpleFrame(); isNonProbingPacket |= updateSimpleFrameOnPacketReceived( @@ -1273,7 +1273,7 @@ void onServerReadDataFromClosed( // Only process the close frames in the packet for (auto& quicFrame : regularPacket.frames) { switch (quicFrame.type()) { - case QuicFrame::Type::ConnectionCloseFrame_E: { + case QuicFrame::Type::ConnectionCloseFrame: { ConnectionCloseFrame& connFrame = *quicFrame.asConnectionCloseFrame(); auto errMsg = folly::to( "Server closed by peer reason=", connFrame.reasonPhrase); diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp index 17e1425c8..9631c82e7 100644 --- a/quic/server/test/QuicServerTransportTest.cpp +++ b/quic/server/test/QuicServerTransportTest.cpp @@ -542,10 +542,10 @@ class QuicServerTransportTest : public Test { for (const auto& packet : server->getConn().outstandings.packets) { for (const auto& frame : packet.packet.frames) { switch (frame.type()) { - case QuicWriteFrame::Type::QuicSimpleFrame_E: { + case QuicWriteFrame::Type::QuicSimpleFrame: { const auto writeFrame = frame.asQuicSimpleFrame(); if (writeFrame->type() == - QuicSimpleFrame::Type::NewConnectionIdFrame_E) { + QuicSimpleFrame::Type::NewConnectionIdFrame) { ++numNewConnIdFrames; } break; @@ -640,7 +640,7 @@ class QuicServerTransportTest : public Test { auto result = clientReadCodec->parsePacket(packetQueue, ackStates); auto& parsedPacket = *result.regularPacket(); for (auto& frame : parsedPacket.frames) { - if (frame.type() != QuicFrame::Type::ReadCryptoFrame_E) { + if (frame.type() != QuicFrame::Type::ReadCryptoFrame) { continue; } cryptoBuf->prependChain(frame.asReadCryptoFrame()->data->clone()); @@ -935,9 +935,9 @@ TEST_F(QuicServerTransportTest, IdleTimeoutExpired) { EXPECT_TRUE(server->isClosed()); auto serverReadCodec = makeClientEncryptedCodec(); EXPECT_FALSE(verifyFramePresent( - serverWrites, *serverReadCodec, QuicFrame::Type::ConnectionCloseFrame_E)); + serverWrites, *serverReadCodec, QuicFrame::Type::ConnectionCloseFrame)); EXPECT_FALSE(verifyFramePresent( - serverWrites, *serverReadCodec, QuicFrame::Type::ConnectionCloseFrame_E)); + serverWrites, *serverReadCodec, QuicFrame::Type::ConnectionCloseFrame)); } TEST_F(QuicServerTransportTest, RecvDataAfterIdleTimeout) { @@ -954,7 +954,7 @@ TEST_F(QuicServerTransportTest, RecvDataAfterIdleTimeout) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(true), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } TEST_F(QuicServerTransportTest, TestCloseConnectionWithError) { @@ -964,7 +964,7 @@ TEST_F(QuicServerTransportTest, TestCloseConnectionWithError) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } TEST_F(QuicServerTransportTest, TestCloseConnectionWithNoError) { @@ -974,7 +974,7 @@ TEST_F(QuicServerTransportTest, TestCloseConnectionWithNoError) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } TEST_F(QuicServerTransportTest, TestClientAddressChanges) { @@ -988,7 +988,7 @@ TEST_F(QuicServerTransportTest, TestClientAddressChanges) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); std::vector indices = getQLogEventIndices(QLogEventType::PacketDrop, qLogger); @@ -1031,7 +1031,7 @@ TEST_F(QuicServerTransportTest, TestCloseConnectionWithNoErrorPendingStreams) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } TEST_F(QuicServerTransportTest, ReceivePacketAfterLocalError) { @@ -1055,7 +1055,7 @@ TEST_F(QuicServerTransportTest, ReceivePacketAfterLocalError) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); serverWrites.clear(); ShortHeader header2( @@ -1075,7 +1075,7 @@ TEST_F(QuicServerTransportTest, ReceivePacketAfterLocalError) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); } TEST_F(QuicServerTransportTest, ReceiveCloseAfterLocalError) { @@ -1102,7 +1102,7 @@ TEST_F(QuicServerTransportTest, ReceiveCloseAfterLocalError) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); serverWrites.clear(); auto currLargestReceivedPacketNum = @@ -1128,7 +1128,7 @@ TEST_F(QuicServerTransportTest, ReceiveCloseAfterLocalError) { EXPECT_FALSE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); EXPECT_GT( server->getConn().ackStates.appDataAckState.largestReceivedPacketNum, currLargestReceivedPacketNum); @@ -1143,7 +1143,7 @@ TEST_F(QuicServerTransportTest, ReceiveCloseAfterLocalError) { EXPECT_FALSE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); checkTransportStateUpdate( qLogger, "Server closed by peer reason=Mind the gap"); } @@ -1184,7 +1184,7 @@ TEST_F(QuicServerTransportTest, NoDataExceptCloseProcessedAfterClosing) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); EXPECT_TRUE(hasNotReceivedNewPacketsSinceLastCloseSent(server->getConn())); serverWrites.clear(); @@ -1197,11 +1197,11 @@ TEST_F(QuicServerTransportTest, NoDataExceptCloseProcessedAfterClosing) { EXPECT_FALSE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); EXPECT_FALSE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); EXPECT_EQ(server->getConn().streamManager->streamCount(), 0); } @@ -1270,8 +1270,8 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) { EXPECT_EQ( stream->retransmissionBuffer.size(), originalRetransSize - buffersInPacket1); - EXPECT_EQ(stream->sendState, StreamSendState::Open_E); - EXPECT_EQ(stream->recvState, StreamRecvState::Open_E); + EXPECT_EQ(stream->sendState, StreamSendState::Open); + EXPECT_EQ(stream->recvState, StreamRecvState::Open); // Dup ack auto packet2 = createAckPacket( @@ -1284,8 +1284,8 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) { EXPECT_EQ( stream->retransmissionBuffer.size(), originalRetransSize - buffersInPacket1); - EXPECT_EQ(stream->sendState, StreamSendState::Open_E); - EXPECT_EQ(stream->recvState, StreamRecvState::Open_E); + EXPECT_EQ(stream->sendState, StreamSendState::Open); + EXPECT_EQ(stream->recvState, StreamRecvState::Open); AckBlocks acks2 = {{packetNum1, lastPacketNum}}; auto packet3 = createAckPacket( @@ -1296,8 +1296,8 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) { deliverData(packetToBuf(packet3)); EXPECT_EQ(stream->retransmissionBuffer.size(), 0); - EXPECT_EQ(stream->sendState, StreamSendState::Open_E); - EXPECT_EQ(stream->recvState, StreamRecvState::Open_E); + EXPECT_EQ(stream->sendState, StreamSendState::Open); + EXPECT_EQ(stream->recvState, StreamRecvState::Open); auto empty = IOBuf::create(0); server->writeChain(streamId, std::move(empty), true, false); @@ -1316,8 +1316,8 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) { acks3, PacketNumberSpace::AppData); deliverData(packetToBuf(packet4)); - EXPECT_EQ(stream->sendState, StreamSendState::Closed_E); - EXPECT_EQ(stream->recvState, StreamRecvState::Open_E); + EXPECT_EQ(stream->sendState, StreamSendState::Closed); + EXPECT_EQ(stream->recvState, StreamRecvState::Open); } TEST_F(QuicServerTransportTest, RecvRstStreamFrameNonexistClientStream) { @@ -1820,7 +1820,7 @@ TEST_F(QuicServerTransportTest, TestCloneStopSending) { auto packetItr = std::find_if( server->getNonConstConn().outstandings.packets.begin(), server->getNonConstConn().outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); ASSERT_TRUE( packetItr != server->getNonConstConn().outstandings.packets.end()); @@ -1830,7 +1830,7 @@ TEST_F(QuicServerTransportTest, TestCloneStopSending) { auto numStopSendingPackets = std::count_if( server->getNonConstConn().outstandings.packets.begin(), server->getNonConstConn().outstandings.packets.end(), - findFrameInPacketFunc()); + findFrameInPacketFunc()); EXPECT_GT(numStopSendingPackets, 1); @@ -1847,8 +1847,7 @@ TEST_F(QuicServerTransportTest, TestAckStopSending) { server->getNonConstConn().streamManager->getStream(streamId); server->stopSending(streamId, GenericApplicationErrorCode::UNKNOWN); loopForWrites(); - auto match = - findFrameInPacketFunc(); + auto match = findFrameInPacketFunc(); auto op = findOutstandingPacket(server->getNonConstConn(), match); ASSERT_TRUE(op != nullptr); @@ -1947,7 +1946,7 @@ TEST_F(QuicServerTransportTest, ReceiveConnectionClose) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); checkTransportStateUpdate(qLogger, std::move(closedMsg)); } @@ -1989,7 +1988,7 @@ TEST_F(QuicServerTransportTest, ReceiveApplicationClose) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); checkTransportStateUpdate(qLogger, std::move(closedMsg)); } @@ -2026,13 +2025,13 @@ TEST_F(QuicServerTransportTest, ReceiveConnectionCloseTwice) { EXPECT_TRUE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); serverWrites.clear(); deliverDataWithoutErrorCheck(packetToBuf(packet)); EXPECT_FALSE(verifyFramePresent( serverWrites, *makeClientEncryptedCodec(), - QuicFrame::Type::ConnectionCloseFrame_E)); + QuicFrame::Type::ConnectionCloseFrame)); std::vector indices = getQLogEventIndices(QLogEventType::PacketDrop, qLogger); EXPECT_EQ(indices.size(), 1); diff --git a/quic/state/QPRFunctions.cpp b/quic/state/QPRFunctions.cpp index 27e62b598..e472dc253 100644 --- a/quic/state/QPRFunctions.cpp +++ b/quic/state/QPRFunctions.cpp @@ -138,7 +138,7 @@ void onRecvMinStreamDataFrame( PacketNum packetNum) { if (isReceivingStream(stream->conn.nodeType, stream->id) || (isSendingStream(stream->conn.nodeType, stream->id) && - stream->sendState != StreamSendState::Open_E)) { + stream->sendState != StreamSendState::Open)) { throw QuicTransportException( "MinStreamDataFrame on receiving-only stream or " "sending-only stream but not opened", diff --git a/quic/state/SimpleFrameFunctions.cpp b/quic/state/SimpleFrameFunctions.cpp index e1adfa40c..7688677b0 100644 --- a/quic/state/SimpleFrameFunctions.cpp +++ b/quic/state/SimpleFrameFunctions.cpp @@ -22,25 +22,25 @@ folly::Optional updateSimpleFrameOnPacketClone( QuicConnectionStateBase& conn, const QuicSimpleFrame& frame) { switch (frame.type()) { - case QuicSimpleFrame::Type::StopSendingFrame_E: + case QuicSimpleFrame::Type::StopSendingFrame: if (!conn.streamManager->streamExists( frame.asStopSendingFrame()->streamId)) { return folly::none; } return QuicSimpleFrame(frame); - case QuicSimpleFrame::Type::MinStreamDataFrame_E: + case QuicSimpleFrame::Type::MinStreamDataFrame: if (!conn.streamManager->streamExists( frame.asMinStreamDataFrame()->streamId)) { return folly::none; } return QuicSimpleFrame(frame); - case QuicSimpleFrame::Type::ExpiredStreamDataFrame_E: + case QuicSimpleFrame::Type::ExpiredStreamDataFrame: if (!conn.streamManager->streamExists( frame.asExpiredStreamDataFrame()->streamId)) { return folly::none; } return QuicSimpleFrame(frame); - case QuicSimpleFrame::Type::PathChallengeFrame_E: + case QuicSimpleFrame::Type::PathChallengeFrame: // Path validation timer expired, path validation failed; // or a different path validation was scheduled if (!conn.outstandingPathValidation || @@ -48,14 +48,14 @@ folly::Optional updateSimpleFrameOnPacketClone( return folly::none; } return QuicSimpleFrame(frame); - case QuicSimpleFrame::Type::PathResponseFrame_E: + case QuicSimpleFrame::Type::PathResponseFrame: // Do not clone PATH_RESPONSE to avoid buffering return folly::none; - case QuicSimpleFrame::Type::NewConnectionIdFrame_E: - case QuicSimpleFrame::Type::MaxStreamsFrame_E: - case QuicSimpleFrame::Type::HandshakeDoneFrame_E: - case QuicSimpleFrame::Type::KnobFrame_E: - case QuicSimpleFrame::Type::RetireConnectionIdFrame_E: + case QuicSimpleFrame::Type::NewConnectionIdFrame: + case QuicSimpleFrame::Type::MaxStreamsFrame: + case QuicSimpleFrame::Type::HandshakeDoneFrame: + case QuicSimpleFrame::Type::KnobFrame: + case QuicSimpleFrame::Type::RetireConnectionIdFrame: // TODO junqiw return QuicSimpleFrame(frame); } @@ -66,7 +66,7 @@ void updateSimpleFrameOnPacketSent( QuicConnectionStateBase& conn, const QuicSimpleFrame& simpleFrame) { switch (simpleFrame.type()) { - case QuicSimpleFrame::Type::PathChallengeFrame_E: + case QuicSimpleFrame::Type::PathChallengeFrame: conn.outstandingPathValidation = std::move(conn.pendingEvents.pathChallenge); conn.pendingEvents.schedulePathValidationTimeout = true; @@ -87,14 +87,14 @@ void updateSimpleFrameOnPacketLoss( QuicConnectionStateBase& conn, const QuicSimpleFrame& frame) { switch (frame.type()) { - case QuicSimpleFrame::Type::StopSendingFrame_E: { + case QuicSimpleFrame::Type::StopSendingFrame: { const StopSendingFrame& stopSendingFrame = *frame.asStopSendingFrame(); if (conn.streamManager->streamExists(stopSendingFrame.streamId)) { conn.pendingEvents.frames.push_back(stopSendingFrame); } break; } - case QuicSimpleFrame::Type::MinStreamDataFrame_E: { + case QuicSimpleFrame::Type::MinStreamDataFrame: { const MinStreamDataFrame& minStreamData = *frame.asMinStreamDataFrame(); auto stream = conn.streamManager->getStream(minStreamData.streamId); if (stream && stream->conn.partialReliabilityEnabled) { @@ -102,7 +102,7 @@ void updateSimpleFrameOnPacketLoss( } break; } - case QuicSimpleFrame::Type::ExpiredStreamDataFrame_E: { + case QuicSimpleFrame::Type::ExpiredStreamDataFrame: { const ExpiredStreamDataFrame& expiredFrame = *frame.asExpiredStreamDataFrame(); auto stream = conn.streamManager->getStream(expiredFrame.streamId); @@ -112,7 +112,7 @@ void updateSimpleFrameOnPacketLoss( } break; } - case QuicSimpleFrame::Type::PathChallengeFrame_E: { + case QuicSimpleFrame::Type::PathChallengeFrame: { const PathChallengeFrame& pathChallenge = *frame.asPathChallengeFrame(); if (conn.outstandingPathValidation && pathChallenge == *conn.outstandingPathValidation) { @@ -120,18 +120,18 @@ void updateSimpleFrameOnPacketLoss( } break; } - case QuicSimpleFrame::Type::PathResponseFrame_E: { + case QuicSimpleFrame::Type::PathResponseFrame: { // Do not retransmit PATH_RESPONSE to avoid buffering break; } - case QuicSimpleFrame::Type::HandshakeDoneFrame_E: { + case QuicSimpleFrame::Type::HandshakeDoneFrame: { const auto& handshakeDoneFrame = *frame.asHandshakeDoneFrame(); conn.pendingEvents.frames.push_back(handshakeDoneFrame); } - case QuicSimpleFrame::Type::NewConnectionIdFrame_E: - case QuicSimpleFrame::Type::MaxStreamsFrame_E: - case QuicSimpleFrame::Type::RetireConnectionIdFrame_E: - case QuicSimpleFrame::Type::KnobFrame_E: + case QuicSimpleFrame::Type::NewConnectionIdFrame: + case QuicSimpleFrame::Type::MaxStreamsFrame: + case QuicSimpleFrame::Type::RetireConnectionIdFrame: + case QuicSimpleFrame::Type::KnobFrame: conn.pendingEvents.frames.push_back(frame); break; } @@ -143,7 +143,7 @@ bool updateSimpleFrameOnPacketReceived( PacketNum packetNum, bool fromChangedPeerAddress) { switch (frame.type()) { - case QuicSimpleFrame::Type::StopSendingFrame_E: { + case QuicSimpleFrame::Type::StopSendingFrame: { const StopSendingFrame& stopSending = *frame.asStopSendingFrame(); auto stream = conn.streamManager->getStream(stopSending.streamId); if (stream) { @@ -151,7 +151,7 @@ bool updateSimpleFrameOnPacketReceived( } return true; } - case QuicSimpleFrame::Type::MinStreamDataFrame_E: { + case QuicSimpleFrame::Type::MinStreamDataFrame: { const MinStreamDataFrame& minStreamData = *frame.asMinStreamDataFrame(); auto stream = conn.streamManager->getStream(minStreamData.streamId); if (stream && stream->conn.partialReliabilityEnabled) { @@ -159,7 +159,7 @@ bool updateSimpleFrameOnPacketReceived( } return true; } - case QuicSimpleFrame::Type::ExpiredStreamDataFrame_E: { + case QuicSimpleFrame::Type::ExpiredStreamDataFrame: { const ExpiredStreamDataFrame& expiredStreamData = *frame.asExpiredStreamDataFrame(); auto stream = conn.streamManager->getStream(expiredStreamData.streamId); @@ -168,7 +168,7 @@ bool updateSimpleFrameOnPacketReceived( } return true; } - case QuicSimpleFrame::Type::PathChallengeFrame_E: { + case QuicSimpleFrame::Type::PathChallengeFrame: { bool rotatedId = conn.retireAndSwitchPeerConnectionIds(); if (!rotatedId) { throw QuicTransportException( @@ -181,7 +181,7 @@ bool updateSimpleFrameOnPacketReceived( PathResponseFrame(pathChallenge.pathData)); return false; } - case QuicSimpleFrame::Type::PathResponseFrame_E: { + case QuicSimpleFrame::Type::PathResponseFrame: { const PathResponseFrame& pathResponse = *frame.asPathResponseFrame(); // Ignore the response if outstandingPathValidation is none or // the path data doesn't match what's in outstandingPathValidation @@ -204,7 +204,7 @@ bool updateSimpleFrameOnPacketReceived( return false; } - case QuicSimpleFrame::Type::NewConnectionIdFrame_E: { + case QuicSimpleFrame::Type::NewConnectionIdFrame: { const NewConnectionIdFrame& newConnectionId = *frame.asNewConnectionIdFrame(); @@ -259,7 +259,7 @@ bool updateSimpleFrameOnPacketReceived( newConnectionId.token); return false; } - case QuicSimpleFrame::Type::MaxStreamsFrame_E: { + case QuicSimpleFrame::Type::MaxStreamsFrame: { const MaxStreamsFrame& maxStreamsFrame = *frame.asMaxStreamsFrame(); if (maxStreamsFrame.isForBidirectionalStream()) { conn.streamManager->setMaxLocalBidirectionalStreams( @@ -270,10 +270,10 @@ bool updateSimpleFrameOnPacketReceived( } return true; } - case QuicSimpleFrame::Type::RetireConnectionIdFrame_E: { + case QuicSimpleFrame::Type::RetireConnectionIdFrame: { return true; } - case QuicSimpleFrame::Type::HandshakeDoneFrame_E: { + case QuicSimpleFrame::Type::HandshakeDoneFrame: { if (conn.nodeType == QuicNodeType::Server) { throw QuicTransportException( "Received HANDSHAKE_DONE from client.", @@ -286,7 +286,7 @@ bool updateSimpleFrameOnPacketReceived( conn.handshakeLayer->handshakeConfirmed(); return true; } - case QuicSimpleFrame::Type::KnobFrame_E: { + case QuicSimpleFrame::Type::KnobFrame: { // TODO it's const so we have to copy it const KnobFrame& knobFrame = *frame.asKnobFrame(); conn.pendingEvents.knobs.emplace_back( diff --git a/quic/state/StateData.cpp b/quic/state/StateData.cpp index 2873be633..e1537b91d 100644 --- a/quic/state/StateData.cpp +++ b/quic/state/StateData.cpp @@ -33,9 +33,9 @@ QuicStreamState::QuicStreamState(StreamId idIn, QuicConnectionStateBase& connIn) : conn.flowControlState.peerAdvertisedInitialMaxStreamOffsetBidiLocal; if (isUnidirectionalStream(idIn)) { if (isLocalStream(connIn.nodeType, idIn)) { - recvState = StreamRecvState::Invalid_E; + recvState = StreamRecvState::Invalid; } else { - sendState = StreamSendState::Invalid_E; + sendState = StreamSendState::Invalid; } } } diff --git a/quic/state/StreamData.h b/quic/state/StreamData.h index 20cf11afd..224564334 100644 --- a/quic/state/StreamData.h +++ b/quic/state/StreamData.h @@ -122,24 +122,19 @@ struct QuicStreamLike { struct QuicConnectionStateBase; -enum class StreamSendState : uint8_t { - Open_E, - ResetSent_E, - Closed_E, - Invalid_E -}; +enum class StreamSendState : uint8_t { Open, ResetSent, Closed, Invalid }; -enum class StreamRecvState : uint8_t { Open_E, Closed_E, Invalid_E }; +enum class StreamRecvState : uint8_t { Open, Closed, Invalid }; inline folly::StringPiece streamStateToString(StreamSendState state) { switch (state) { - case StreamSendState::Open_E: + case StreamSendState::Open: return "Open"; - case StreamSendState::ResetSent_E: + case StreamSendState::ResetSent: return "ResetSent"; - case StreamSendState::Closed_E: + case StreamSendState::Closed: return "Closed"; - case StreamSendState::Invalid_E: + case StreamSendState::Invalid: return "Invalid"; } return "Unknown"; @@ -147,11 +142,11 @@ inline folly::StringPiece streamStateToString(StreamSendState state) { inline folly::StringPiece streamStateToString(StreamRecvState state) { switch (state) { - case StreamRecvState::Open_E: + case StreamRecvState::Open: return "Open"; - case StreamRecvState::Closed_E: + case StreamRecvState::Closed: return "Closed"; - case StreamRecvState::Invalid_E: + case StreamRecvState::Invalid: return "Invalid"; } return "Unknown"; @@ -189,10 +184,10 @@ struct QuicStreamState : public QuicStreamLike { folly::Optional streamWriteError; // State machine data - StreamSendState sendState{StreamSendState::Open_E}; + StreamSendState sendState{StreamSendState::Open}; // State machine data - StreamRecvState recvState{StreamRecvState::Open_E}; + StreamRecvState recvState{StreamRecvState::Open}; // Tells whether this stream is a control stream. // It is set by the app via setControlStream and the transport can use this @@ -215,23 +210,22 @@ struct QuicStreamState : public QuicStreamLike { // Returns true if both send and receive state machines are in a terminal // state bool inTerminalStates() const { - bool sendInTerminalState = sendState == StreamSendState::Closed_E || - sendState == StreamSendState::Invalid_E; + bool sendInTerminalState = sendState == StreamSendState::Closed || + sendState == StreamSendState::Invalid; - bool recvInTerminalState = recvState == StreamRecvState::Closed_E || - recvState == StreamRecvState::Invalid_E; + bool recvInTerminalState = recvState == StreamRecvState::Closed || + recvState == StreamRecvState::Invalid; return sendInTerminalState && recvInTerminalState; } // If the stream is still writable. bool writable() const { - return sendState == StreamSendState::Open_E && - !finalWriteOffset.has_value(); + return sendState == StreamSendState::Open && !finalWriteOffset.has_value(); } bool shouldSendFlowControl() const { - return recvState == StreamRecvState::Open_E; + return recvState == StreamRecvState::Open; } bool hasWritableData() const { diff --git a/quic/state/stream/StreamReceiveHandlers.cpp b/quic/state/stream/StreamReceiveHandlers.cpp index 222db9d93..dbb52f13d 100644 --- a/quic/state/stream/StreamReceiveHandlers.cpp +++ b/quic/state/stream/StreamReceiveHandlers.cpp @@ -32,7 +32,7 @@ void receiveReadStreamFrameSMHandler( QuicStreamState& stream, ReadStreamFrame&& frame) { switch (stream.recvState) { - case StreamRecvState::Open_E: { + case StreamRecvState::Open: { VLOG_IF(10, frame.fin) << "Open: Received data with fin" << " stream=" << stream.id << " " << stream.conn; appendDataToReadBuffer( @@ -40,7 +40,7 @@ void receiveReadStreamFrameSMHandler( if (isAllDataReceived(stream)) { VLOG(10) << "Open: Transition to Closed" << " stream=" << stream.id << " " << stream.conn; - stream.recvState = StreamRecvState::Closed_E; + stream.recvState = StreamRecvState::Closed; if (stream.inTerminalStates()) { stream.conn.streamManager->addClosed(stream.id); } @@ -50,7 +50,7 @@ void receiveReadStreamFrameSMHandler( stream.conn.streamManager->updatePeekableStreams(stream); break; } - case StreamRecvState::Closed_E: { + case StreamRecvState::Closed: { CHECK(!isSendingStream(stream.conn.nodeType, stream.id)); VLOG_IF(10, frame.fin) << "Closed: Received data with fin" << " stream=" << stream.id << " " << stream.conn; @@ -58,7 +58,7 @@ void receiveReadStreamFrameSMHandler( stream, StreamBuffer(std::move(frame.data), frame.offset, frame.fin)); break; } - case StreamRecvState::Invalid_E: { + case StreamRecvState::Invalid: { throw QuicTransportException( folly::to( "Invalid transition from state=", @@ -70,23 +70,23 @@ void receiveReadStreamFrameSMHandler( void receiveRstStreamSMHandler(QuicStreamState& stream, RstStreamFrame&& rst) { switch (stream.recvState) { - case StreamRecvState::Closed_E: { + case StreamRecvState::Closed: { // This will check whether the reset is still consistent with the stream. onResetQuicStream(stream, std::move(rst)); break; } - case StreamRecvState::Open_E: { + case StreamRecvState::Open: { // We transit the receive state machine to Closed before invoking // onResetQuicStream because it will check the state of the stream for // flow control. - stream.recvState = StreamRecvState::Closed_E; + stream.recvState = StreamRecvState::Closed; if (stream.inTerminalStates()) { stream.conn.streamManager->addClosed(stream.id); } onResetQuicStream(stream, std::move(rst)); break; } - case StreamRecvState::Invalid_E: { + case StreamRecvState::Invalid: { throw QuicTransportException( folly::to( "Invalid transition from state=", diff --git a/quic/state/stream/StreamSendHandlers.cpp b/quic/state/stream/StreamSendHandlers.cpp index 4f83397d3..25e263774 100644 --- a/quic/state/stream/StreamSendHandlers.cpp +++ b/quic/state/stream/StreamSendHandlers.cpp @@ -35,21 +35,21 @@ void sendStopSendingSMHandler( QuicStreamState& stream, const StopSendingFrame& frame) { switch (stream.sendState) { - case StreamSendState::Open_E: { + case StreamSendState::Open: { CHECK( isBidirectionalStream(stream.id) || isSendingStream(stream.conn.nodeType, stream.id)); stream.conn.streamManager->addStopSending(stream.id, frame.errorCode); break; } - case StreamSendState::Closed_E: { + case StreamSendState::Closed: { break; } - case StreamSendState::ResetSent_E: { + case StreamSendState::ResetSent: { // no-op, we already sent a reset break; } - case StreamSendState::Invalid_E: { + case StreamSendState::Invalid: { throw QuicTransportException( folly::to( "Invalid transition from state=", @@ -61,21 +61,21 @@ void sendStopSendingSMHandler( void sendRstSMHandler(QuicStreamState& stream, ApplicationErrorCode errorCode) { switch (stream.sendState) { - case StreamSendState::Open_E: { + case StreamSendState::Open: { resetQuicStream(stream, errorCode); appendPendingStreamReset(stream.conn, stream, errorCode); - stream.sendState = StreamSendState::ResetSent_E; + stream.sendState = StreamSendState::ResetSent; break; } - case StreamSendState::Closed_E: { + case StreamSendState::Closed: { VLOG(4) << "Ignoring SendReset from closed state."; break; } - case StreamSendState::ResetSent_E: { + case StreamSendState::ResetSent: { // do nothing break; } - case StreamSendState::Invalid_E: { + case StreamSendState::Invalid: { throw QuicTransportException( folly::to( "Invalid transition from state=", @@ -89,7 +89,7 @@ void sendAckSMHandler( QuicStreamState& stream, const WriteStreamFrame& ackedFrame) { switch (stream.sendState) { - case StreamSendState::Open_E: { + case StreamSendState::Open: { // Clean up the acked buffers from the retransmissionBuffer. auto ackedBuffer = stream.retransmissionBuffer.find(ackedFrame.offset); if (ackedBuffer != stream.retransmissionBuffer.end()) { @@ -118,20 +118,20 @@ void sendAckSMHandler( // Check for whether or not we have ACKed all bytes until our FIN. if (allBytesTillFinAcked(stream)) { - stream.sendState = StreamSendState::Closed_E; + stream.sendState = StreamSendState::Closed; if (stream.inTerminalStates()) { stream.conn.streamManager->addClosed(stream.id); } } break; } - case StreamSendState::Closed_E: - case StreamSendState::ResetSent_E: { + case StreamSendState::Closed: + case StreamSendState::ResetSent: { DCHECK(stream.retransmissionBuffer.empty()); DCHECK(stream.writeBuffer.empty()); break; } - case StreamSendState::Invalid_E: { + case StreamSendState::Invalid: { throw QuicTransportException( folly::to( "Invalid transition from state=", @@ -144,21 +144,21 @@ void sendAckSMHandler( void sendRstAckSMHandler(QuicStreamState& stream) { switch (stream.sendState) { - case StreamSendState::ResetSent_E: { + case StreamSendState::ResetSent: { VLOG(10) << "ResetSent: Transition to closed stream=" << stream.id << " " << stream.conn; - stream.sendState = StreamSendState::Closed_E; + stream.sendState = StreamSendState::Closed; if (stream.inTerminalStates()) { stream.conn.streamManager->addClosed(stream.id); } break; } - case StreamSendState::Closed_E: { + case StreamSendState::Closed: { // Just discard the ack if we are already in Closed state. break; } - case StreamSendState::Open_E: - case StreamSendState::Invalid_E: { + case StreamSendState::Open: + case StreamSendState::Invalid: { throw QuicTransportException( folly::to( "Invalid transition from state=", diff --git a/quic/state/stream/test/StreamStateMachineTest.cpp b/quic/state/stream/test/StreamStateMachineTest.cpp index b6c7547df..547f3a01c 100644 --- a/quic/state/stream/test/StreamStateMachineTest.cpp +++ b/quic/state/stream/test/StreamStateMachineTest.cpp @@ -66,7 +66,7 @@ TEST_F(QuicOpenStateTest, ReadStreamDataNotFin) { receiveReadStreamFrameSMHandler(stream, std::move(frame)); EXPECT_TRUE(stream.hasReadableData()); EXPECT_TRUE(stream.hasPeekableData()); - EXPECT_EQ(stream.recvState, StreamRecvState::Open_E); + EXPECT_EQ(stream.recvState, StreamRecvState::Open); } TEST_F(QuicOpenStateTest, ReadInvalidData) { @@ -80,7 +80,7 @@ TEST_F(QuicOpenStateTest, ReadInvalidData) { ReadStreamFrame frame1(id, offset1, fin1); frame1.data = IOBuf::copyBuffer("hey"); receiveReadStreamFrameSMHandler(stream, std::move(frame1)); - EXPECT_EQ(stream.recvState, StreamRecvState::Open_E); + EXPECT_EQ(stream.recvState, StreamRecvState::Open); uint64_t offset2 = 1; bool fin2 = true; @@ -110,7 +110,7 @@ TEST_F(QuicOpenStateTest, ReceiveStreamFrameWithFIN) { receivedStreamFrame.data = folly::IOBuf::create(10); receivedStreamFrame.data->append(10); receiveReadStreamFrameSMHandler(*stream, std::move(receivedStreamFrame)); - ASSERT_EQ(stream->recvState, StreamRecvState::Closed_E); + ASSERT_EQ(stream->recvState, StreamRecvState::Closed); } TEST_F(QuicOpenStateTest, ReceiveStreamFrameWithFINReadbuffHole) { @@ -124,7 +124,7 @@ TEST_F(QuicOpenStateTest, ReceiveStreamFrameWithFINReadbuffHole) { receivedStreamFrame.data = folly::IOBuf::create(10); receivedStreamFrame.data->append(10); receiveReadStreamFrameSMHandler(*stream, std::move(receivedStreamFrame)); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); } TEST_F(QuicOpenStateTest, ReceiveStreamFrameWithoutFIN) { @@ -138,7 +138,7 @@ TEST_F(QuicOpenStateTest, ReceiveStreamFrameWithoutFIN) { receivedStreamFrame.data = folly::IOBuf::create(10); receivedStreamFrame.data->append(10); receiveReadStreamFrameSMHandler(*stream, std::move(receivedStreamFrame)); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); } TEST_F(QuicOpenStateTest, AckStream) { @@ -169,10 +169,10 @@ TEST_F(QuicOpenStateTest, AckStream) { .asWriteStreamFrame(); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); } TEST_F(QuicOpenStateTest, AckStreamMulti) { @@ -217,7 +217,7 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) { *conn->outstandings.packets[2].packet.frames[0].asWriteStreamFrame(); sendAckSMHandler(*stream, streamFrame3); - ASSERT_EQ(stream->sendState, StreamSendState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Open); ASSERT_EQ(stream->ackedIntervals.front().start, 10); ASSERT_EQ(stream->ackedIntervals.front().end, 21); @@ -225,7 +225,7 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) { *conn->outstandings.packets[1].packet.frames[0].asWriteStreamFrame(); sendAckSMHandler(*stream, streamFrame2); - ASSERT_EQ(stream->sendState, StreamSendState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Open); ASSERT_EQ(stream->ackedIntervals.front().start, 5); ASSERT_EQ(stream->ackedIntervals.front().end, 21); @@ -233,7 +233,7 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) { *conn->outstandings.packets[0].packet.frames[0].asWriteStreamFrame(); sendAckSMHandler(*stream, streamFrame1); - ASSERT_EQ(stream->sendState, StreamSendState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Open); ASSERT_EQ(stream->ackedIntervals.front().start, 0); ASSERT_EQ(stream->ackedIntervals.front().end, 21); } @@ -320,12 +320,12 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkip) { EXPECT_TRUE(stream->retransmissionBuffer.empty()); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); } TEST_F(QuicOpenStateTest, AckStreamAfterSkipHalfBuf) { @@ -365,8 +365,8 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkipHalfBuf) { EXPECT_EQ(stream->retransmissionBuffer.size(), 1); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); } TEST_F(QuicOpenStateTest, AckStreamAfterSkipOneAndAHalfBuf) { @@ -422,15 +422,15 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkipOneAndAHalfBuf) { // discarded after the skip. sendAckSMHandler(*stream, streamFrame1); EXPECT_EQ(stream->retransmissionBuffer.size(), 1); - ASSERT_EQ(stream->sendState, StreamSendState::Open_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Open); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); // Send ack for the second buffer, should clear out the retransmit queue after // correctly identifying adjusted offset. sendAckSMHandler(*stream, streamFrame2); EXPECT_TRUE(stream->retransmissionBuffer.empty()); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); } class QuicResetSentStateTest : public Test {}; @@ -440,7 +440,7 @@ TEST_F(QuicResetSentStateTest, RstAck) { StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::ResetSent_E; + stream.sendState = StreamSendState::ResetSent; stream.currentReadOffset = 0xABCD; stream.finalWriteOffset = 0xACDC; stream.readBuffer.emplace_back( @@ -448,7 +448,7 @@ TEST_F(QuicResetSentStateTest, RstAck) { RstStreamFrame frame(id, GenericApplicationErrorCode::UNKNOWN, 0); sendRstAckSMHandler(stream); - EXPECT_EQ(stream.sendState, StreamSendState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Closed); EXPECT_FALSE(stream.finalReadOffset); EXPECT_FALSE(stream.readBuffer.empty()); } @@ -459,10 +459,10 @@ TEST_F(QuicClosedStateTest, RstAck) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Closed_E; + stream.sendState = StreamSendState::Closed; RstStreamFrame frame(id, GenericApplicationErrorCode::UNKNOWN, 0); sendRstAckSMHandler(stream); - EXPECT_EQ(stream.sendState, StreamSendState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Closed); } class QuicHalfClosedLocalStateTest : public Test {}; @@ -471,8 +471,8 @@ TEST_F(QuicHalfClosedLocalStateTest, ReceiveStreamFrameWithFIN) { auto conn = createConn(); auto stream = conn->streamManager->createNextBidirectionalStream().value(); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Open_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Open; stream->currentReadOffset = 100; // We received FIN and everything: @@ -480,16 +480,16 @@ TEST_F(QuicHalfClosedLocalStateTest, ReceiveStreamFrameWithFIN) { receivedStreamFrame.data = folly::IOBuf::create(10); receivedStreamFrame.data->append(10); receiveReadStreamFrameSMHandler(*stream, std::move(receivedStreamFrame)); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Closed_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Closed); } TEST_F(QuicHalfClosedLocalStateTest, ReceiveStreamFrameWithFINReadbuffHole) { auto conn = createConn(); auto stream = conn->streamManager->createNextBidirectionalStream().value(); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Open_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Open; stream->currentReadOffset = 100; // We received FIN, but we havn't received anything between 100 and 200: @@ -497,16 +497,16 @@ TEST_F(QuicHalfClosedLocalStateTest, ReceiveStreamFrameWithFINReadbuffHole) { receivedStreamFrame.data = folly::IOBuf::create(10); receivedStreamFrame.data->append(10); receiveReadStreamFrameSMHandler(*stream, std::move(receivedStreamFrame)); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); } TEST_F(QuicHalfClosedLocalStateTest, ReceiveStreamFrameWithoutFIN) { auto conn = createConn(); auto stream = conn->streamManager->createNextBidirectionalStream().value(); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Open_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Open; stream->currentReadOffset = 100; // We haven't received FIN: @@ -515,8 +515,8 @@ TEST_F(QuicHalfClosedLocalStateTest, ReceiveStreamFrameWithoutFIN) { receivedStreamFrame.data->append(10); receiveReadStreamFrameSMHandler(*stream, std::move(receivedStreamFrame)); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Open_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Open); } class QuicHalfClosedRemoteStateTest : public Test {}; @@ -528,8 +528,8 @@ TEST_F(QuicHalfClosedRemoteStateTest, AckStream) { auto connIdAlgo = std::make_unique(); auto serverChosenConnId = connIdAlgo->encodeConnectionId(params); auto stream = conn->streamManager->createNextBidirectionalStream().value(); - stream->sendState = StreamSendState::Open_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Open; + stream->recvState = StreamRecvState::Closed; EventBase evb; auto sock = std::make_unique(&evb); @@ -553,10 +553,10 @@ TEST_F(QuicHalfClosedRemoteStateTest, AckStream) { .asWriteStreamFrame(); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); } TEST_F(QuicHalfClosedRemoteStateTest, AckStreamAfterSkip) { @@ -566,8 +566,8 @@ TEST_F(QuicHalfClosedRemoteStateTest, AckStreamAfterSkip) { auto connIdAlgo = std::make_unique(); auto serverChosenConnId = connIdAlgo->encodeConnectionId(params); auto stream = conn->streamManager->createNextBidirectionalStream().value(); - stream->sendState = StreamSendState::Open_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Open; + stream->recvState = StreamRecvState::Closed; EventBase evb; auto sock = std::make_unique(&evb); @@ -598,12 +598,12 @@ TEST_F(QuicHalfClosedRemoteStateTest, AckStreamAfterSkip) { EXPECT_TRUE(stream->retransmissionBuffer.empty()); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Closed_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Closed); sendAckSMHandler(*stream, streamFrame); - ASSERT_EQ(stream->sendState, StreamSendState::Closed_E); - ASSERT_EQ(stream->recvState, StreamRecvState::Closed_E); + ASSERT_EQ(stream->sendState, StreamSendState::Closed); + ASSERT_EQ(stream->recvState, StreamRecvState::Closed); } class QuicSendResetTest : public Test {}; @@ -613,37 +613,37 @@ TEST_F(QuicSendResetTest, FromOpen) { StreamId id = 5; QuicStreamState stream(id, *conn); sendRstSMHandler(stream, GenericApplicationErrorCode::UNKNOWN); - EXPECT_EQ(stream.sendState, StreamSendState::ResetSent_E); + EXPECT_EQ(stream.sendState, StreamSendState::ResetSent); } TEST_F(QuicSendResetTest, FromHalfCloseRemote) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Closed; sendRstSMHandler(stream, GenericApplicationErrorCode::UNKNOWN); - EXPECT_EQ(stream.sendState, StreamSendState::ResetSent_E); + EXPECT_EQ(stream.sendState, StreamSendState::ResetSent); } TEST_F(QuicSendResetTest, FromHalfCloseLocal) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Closed_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::Closed; + stream.recvState = StreamRecvState::Open; sendRstSMHandler(stream, GenericApplicationErrorCode::UNKNOWN); // You cannot send a reset after FIN has been acked - EXPECT_EQ(stream.sendState, StreamSendState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Closed); } TEST_F(QuicSendResetTest, FromClosed) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Closed_E; + stream.sendState = StreamSendState::Closed; sendRstSMHandler(stream, GenericApplicationErrorCode::UNKNOWN); } @@ -652,7 +652,7 @@ TEST_F(QuicSendResetTest, FromResetSent) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::ResetSent_E; + stream.sendState = StreamSendState::ResetSent; sendRstSMHandler(stream, GenericApplicationErrorCode::UNKNOWN); } @@ -666,8 +666,8 @@ TEST_F(QuicRecvResetTest, FromOpen) { RstStreamFrame rst(rstStream, GenericApplicationErrorCode::UNKNOWN, 100); receiveRstStreamSMHandler(stream, std::move(rst)); - EXPECT_EQ(stream.sendState, StreamSendState::Open_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Open); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); verifyStreamReset(stream, 100); } @@ -687,13 +687,13 @@ TEST_F(QuicRecvResetTest, FromHalfClosedRemoteNoReadOffsetYet) { StreamId id = 5; auto conn = createConn(); QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Closed; receiveRstStreamSMHandler( stream, RstStreamFrame(1, GenericApplicationErrorCode::UNKNOWN, 100)); - EXPECT_EQ(stream.sendState, StreamSendState::Open_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Open); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); verifyStreamReset(stream, 100); } @@ -701,14 +701,14 @@ TEST_F(QuicRecvResetTest, FromHalfClosedRemoteReadOffsetMatch) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Closed; stream.finalReadOffset = 1024; receiveRstStreamSMHandler( stream, RstStreamFrame(1, GenericApplicationErrorCode::UNKNOWN, 1024)); - EXPECT_EQ(stream.sendState, StreamSendState::Open_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Open); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); verifyStreamReset(stream, 1024); } @@ -716,8 +716,8 @@ TEST_F(QuicRecvResetTest, FromHalfClosedRemoteReadOffsetMismatch) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Closed; stream.finalReadOffset = 1024; EXPECT_THROW( receiveRstStreamSMHandler( @@ -729,12 +729,12 @@ TEST_F(QuicRecvResetTest, FromHalfClosedLocal) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Closed_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::Closed; + stream.recvState = StreamRecvState::Open; receiveRstStreamSMHandler( stream, RstStreamFrame(1, GenericApplicationErrorCode::UNKNOWN, 200)); - EXPECT_EQ(stream.sendState, StreamSendState::Closed_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Closed); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); verifyStreamReset(stream, 200); } @@ -742,8 +742,8 @@ TEST_F(QuicRecvResetTest, FromHalfClosedLocalReadEOFMismatch) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Closed_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::Closed; + stream.recvState = StreamRecvState::Open; stream.finalReadOffset = 2014; EXPECT_THROW( receiveRstStreamSMHandler( @@ -755,13 +755,13 @@ TEST_F(QuicRecvResetTest, FromResetSentNoReadOffsetYet) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::ResetSent_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::ResetSent; + stream.recvState = StreamRecvState::Open; receiveRstStreamSMHandler( stream, RstStreamFrame(1, GenericApplicationErrorCode::UNKNOWN, 200)); - EXPECT_EQ(stream.sendState, StreamSendState::ResetSent_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::ResetSent); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); verifyStreamReset(stream, 200); } @@ -769,14 +769,14 @@ TEST_F(QuicRecvResetTest, FromResetSentOffsetMatch) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::ResetSent_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::ResetSent; + stream.recvState = StreamRecvState::Open; stream.finalReadOffset = 200; receiveRstStreamSMHandler( stream, RstStreamFrame(1, GenericApplicationErrorCode::UNKNOWN, 200)); - EXPECT_EQ(stream.sendState, StreamSendState::ResetSent_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::ResetSent); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); verifyStreamReset(stream, 200); } @@ -784,8 +784,8 @@ TEST_F(QuicRecvResetTest, FromResetSentOffsetMismatch) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::ResetSent_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::ResetSent; + stream.recvState = StreamRecvState::Open; stream.finalReadOffset = 300; EXPECT_THROW( receiveRstStreamSMHandler( @@ -797,12 +797,12 @@ TEST_F(QuicRecvResetTest, FromClosedNoReadOffsetYet) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Closed_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Closed; + stream.recvState = StreamRecvState::Closed; receiveRstStreamSMHandler( stream, RstStreamFrame(1, GenericApplicationErrorCode::UNKNOWN, 200)); - EXPECT_EQ(stream.sendState, StreamSendState::Closed_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Closed); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); verifyStreamReset(stream, 200); } @@ -810,13 +810,13 @@ TEST_F(QuicRecvResetTest, FromClosedOffsetMatch) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Closed_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Closed; + stream.recvState = StreamRecvState::Closed; stream.finalReadOffset = 1234; receiveRstStreamSMHandler( stream, RstStreamFrame(1, GenericApplicationErrorCode::UNKNOWN, 1234)); - EXPECT_EQ(stream.sendState, StreamSendState::Closed_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Closed); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); verifyStreamReset(stream, 1234); } @@ -824,8 +824,8 @@ TEST_F(QuicRecvResetTest, FromClosedOffsetMismatch) { auto conn = createConn(); StreamId id = 5; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Closed_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Closed; + stream.recvState = StreamRecvState::Closed; stream.finalReadOffset = 123; EXPECT_THROW( receiveRstStreamSMHandler( @@ -840,8 +840,8 @@ TEST_F(QuicUnidirectionalStreamTest, OpenInvalidReadStream) { auto conn = createConn(); StreamId id = 0b111; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Invalid_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Invalid; EXPECT_THROW( receiveReadStreamFrameSMHandler(stream, ReadStreamFrame(id, 1, false)), QuicTransportException); @@ -851,8 +851,8 @@ TEST_F(QuicUnidirectionalStreamTest, OpenInvalidRstStream) { auto conn = createConn(); StreamId id = 0b111; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Invalid_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Invalid; EXPECT_THROW( receiveRstStreamSMHandler( stream, @@ -864,8 +864,8 @@ TEST_F(QuicUnidirectionalStreamTest, OpenInvalidSendReset) { auto conn = createConn(); StreamId id = 0b110; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Invalid_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::Invalid; + stream.recvState = StreamRecvState::Open; EXPECT_THROW( sendRstSMHandler(stream, GenericApplicationErrorCode::UNKNOWN), @@ -876,8 +876,8 @@ TEST_F(QuicUnidirectionalStreamTest, OpenInvalidAckStreamFrame) { auto conn = createConn(); StreamId id = 0b110; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Invalid_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::Invalid; + stream.recvState = StreamRecvState::Open; WriteStreamFrame ackedFrame(id, 0, 0, false); EXPECT_THROW(sendAckSMHandler(stream, ackedFrame), QuicTransportException); } @@ -886,8 +886,8 @@ TEST_F(QuicUnidirectionalStreamTest, OpenInvalidStopSending) { auto conn = createConn(); StreamId id = 0b110; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Invalid_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::Invalid; + stream.recvState = StreamRecvState::Open; EXPECT_THROW( sendStopSendingSMHandler( stream, StopSendingFrame(id, GenericApplicationErrorCode::UNKNOWN)), @@ -898,8 +898,8 @@ TEST_F(QuicUnidirectionalStreamTest, ClosedInvalidReadStream) { auto conn = createConn(); StreamId id = 0b111; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Invalid_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Invalid; EXPECT_THROW( receiveReadStreamFrameSMHandler(stream, ReadStreamFrame(id, 1, false)), QuicTransportException); @@ -909,8 +909,8 @@ TEST_F(QuicUnidirectionalStreamTest, ClosedInvalidRstStream) { auto conn = createConn(); StreamId id = 0b111; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Invalid_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Invalid; EXPECT_THROW( receiveRstStreamSMHandler( stream, @@ -922,8 +922,8 @@ TEST_F(QuicUnidirectionalStreamTest, ClosedInvalidSendReset) { auto conn = createConn(); StreamId id = 0b110; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Invalid_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Invalid; + stream.recvState = StreamRecvState::Closed; EXPECT_THROW( sendRstSMHandler(stream, GenericApplicationErrorCode::UNKNOWN), QuicTransportException); @@ -933,8 +933,8 @@ TEST_F(QuicUnidirectionalStreamTest, ClosedInvalidAckStreamFrame) { auto conn = createConn(); StreamId id = 0b110; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Invalid_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Invalid; + stream.recvState = StreamRecvState::Closed; WriteStreamFrame ackedFrame(id, 0, 0, false); EXPECT_THROW(sendAckSMHandler(stream, ackedFrame), QuicTransportException); @@ -944,8 +944,8 @@ TEST_F(QuicUnidirectionalStreamTest, ClosedInvalidStopSending) { auto conn = createConn(); StreamId id = 0b110; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Invalid_E; - stream.recvState = StreamRecvState::Closed_E; + stream.sendState = StreamSendState::Invalid; + stream.recvState = StreamRecvState::Closed; EXPECT_THROW( sendStopSendingSMHandler( stream, StopSendingFrame(id, GenericApplicationErrorCode::UNKNOWN)), @@ -956,28 +956,28 @@ TEST_F(QuicUnidirectionalStreamTest, OpenReadStreamFin) { auto conn = createConn(); StreamId id = 0b110; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Invalid_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::Invalid; + stream.recvState = StreamRecvState::Open; stream.currentReadOffset = 100; ReadStreamFrame receivedStreamFrame(stream.id, 100, true); receivedStreamFrame.data = folly::IOBuf::create(10); receivedStreamFrame.data->append(10); receiveReadStreamFrameSMHandler(stream, std::move(receivedStreamFrame)); - EXPECT_EQ(stream.sendState, StreamSendState::Invalid_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Invalid); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); } TEST_F(QuicUnidirectionalStreamTest, OpenRstStream) { auto conn = createConn(); StreamId id = 0b110; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::Invalid_E; - stream.recvState = StreamRecvState::Open_E; + stream.sendState = StreamSendState::Invalid; + stream.recvState = StreamRecvState::Open; receiveRstStreamSMHandler( stream, RstStreamFrame(1, GenericApplicationErrorCode::UNKNOWN, 1234)); - EXPECT_EQ(stream.sendState, StreamSendState::Invalid_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Closed_E); + EXPECT_EQ(stream.sendState, StreamSendState::Invalid); + EXPECT_EQ(stream.recvState, StreamRecvState::Closed); } TEST_F(QuicUnidirectionalStreamTest, OpenFinalAckStreamFrame) { @@ -985,8 +985,8 @@ TEST_F(QuicUnidirectionalStreamTest, OpenFinalAckStreamFrame) { StreamId id = 0b111; QuicStreamState stream(id, *conn); WriteStreamFrame streamFrame(id, 1, 1, false); - stream.sendState = StreamSendState::Open_E; - stream.recvState = StreamRecvState::Invalid_E; + stream.sendState = StreamSendState::Open; + stream.recvState = StreamRecvState::Invalid; stream.finalWriteOffset = 1; stream.currentWriteOffset = 2; auto buf = folly::IOBuf::create(1); @@ -997,16 +997,16 @@ TEST_F(QuicUnidirectionalStreamTest, OpenFinalAckStreamFrame) { std::forward_as_tuple( std::make_unique(std::move(buf), 1, false))); sendAckSMHandler(stream, streamFrame); - EXPECT_EQ(stream.sendState, StreamSendState::Closed_E); - EXPECT_EQ(stream.recvState, StreamRecvState::Invalid_E); + EXPECT_EQ(stream.sendState, StreamSendState::Closed); + EXPECT_EQ(stream.recvState, StreamRecvState::Invalid); } TEST_F(QuicUnidirectionalStreamTest, ResetSentInvalidReadStream) { auto conn = createConn(); StreamId id = 0b111; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::ResetSent_E; - stream.recvState = StreamRecvState::Invalid_E; + stream.sendState = StreamSendState::ResetSent; + stream.recvState = StreamRecvState::Invalid; EXPECT_THROW( receiveReadStreamFrameSMHandler(stream, ReadStreamFrame(id, 1, false)), QuicTransportException); @@ -1016,8 +1016,8 @@ TEST_F(QuicUnidirectionalStreamTest, ResetSentInvalidRstStream) { auto conn = createConn(); StreamId id = 0b111; QuicStreamState stream(id, *conn); - stream.sendState = StreamSendState::ResetSent_E; - stream.recvState = StreamRecvState::Invalid_E; + stream.sendState = StreamSendState::ResetSent; + stream.recvState = StreamRecvState::Invalid; EXPECT_THROW( receiveRstStreamSMHandler( stream, diff --git a/quic/state/test/QPRFunctionsTest.cpp b/quic/state/test/QPRFunctionsTest.cpp index b087ce938..2e479a1d1 100644 --- a/quic/state/test/QPRFunctionsTest.cpp +++ b/quic/state/test/QPRFunctionsTest.cpp @@ -203,8 +203,8 @@ TEST_F(QPRFunctionsTest, RecvMinStreamDataFrameShrinkBuffer) { TEST_F(QPRFunctionsTest, RecvMinStreamDataFrameOnUnidirectionalStream) { auto stream = conn.streamManager->createNextUnidirectionalStream().value(); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; PacketNum packetNum(10); MinStreamDataFrame frame( stream->id, stream->flowControlState.peerAdvertisedMaxOffset + 100, 100); diff --git a/quic/state/test/QuicStateFunctionsTest.cpp b/quic/state/test/QuicStateFunctionsTest.cpp index 0c7747ed0..7f9b2ae4e 100644 --- a/quic/state/test/QuicStateFunctionsTest.cpp +++ b/quic/state/test/QuicStateFunctionsTest.cpp @@ -441,7 +441,7 @@ TEST_F(QuicStateFunctionsTest, TestInvokeStreamStateMachineConnectionError) { receiveRstStreamSMHandler(stream, std::move(rst)), QuicTransportException); // This doesn't change the send state machine implicitly anymore - bool matches = (stream.sendState == StreamSendState::Open_E); + bool matches = (stream.sendState == StreamSendState::Open); EXPECT_TRUE(matches); } @@ -456,7 +456,7 @@ TEST_F(QuicStateFunctionsTest, InvokeResetDoesNotSendFlowControl) { conn.flowControlState.advertisedMaxOffset = 100; conn.flowControlState.windowSize = 100; receiveRstStreamSMHandler(stream, std::move(rst)); - bool matches = (stream.recvState == StreamRecvState::Closed_E); + bool matches = (stream.recvState == StreamRecvState::Closed); EXPECT_TRUE(matches); EXPECT_FALSE(conn.streamManager->hasWindowUpdates()); EXPECT_TRUE(conn.pendingEvents.connWindowUpdate); @@ -475,7 +475,7 @@ TEST_F(QuicStateFunctionsTest, TestInvokeStreamStateMachineStreamError) { } catch (QuicTransportException& ex) { EXPECT_EQ(ex.errorCode(), TransportErrorCode::STREAM_STATE_ERROR); } - bool matches = (stream.sendState == StreamSendState::Open_E); + bool matches = (stream.sendState == StreamSendState::Open); EXPECT_TRUE(matches); } diff --git a/quic/state/test/QuicStreamFunctionsTest.cpp b/quic/state/test/QuicStreamFunctionsTest.cpp index 3370bba9e..c34b68f36 100644 --- a/quic/state/test/QuicStreamFunctionsTest.cpp +++ b/quic/state/test/QuicStreamFunctionsTest.cpp @@ -1546,8 +1546,8 @@ TEST_F(QuicStreamFunctionsTest, RemovedClosedState) { conn.streamManager->queueFlowControlUpdated(streamId); conn.streamManager->addDataRejected(streamId); conn.streamManager->addDataExpired(streamId); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; conn.streamManager->removeClosedStream(streamId); EXPECT_FALSE(conn.streamManager->streamExists(streamId)); EXPECT_TRUE(conn.streamManager->readableStreams().empty()); @@ -1639,7 +1639,7 @@ TEST_F(QuicServerStreamFunctionsTest, ServerGetCloseBothDirections) { EXPECT_EQ(conn.streamManager->getStream(serverBiStream)->id, serverBiStream); StreamId serverUniStream = 0x0B; auto stream = conn.streamManager->createStream(serverUniStream).value(); - stream->sendState = StreamSendState::Closed_E; + stream->sendState = StreamSendState::Closed; conn.streamManager->removeClosedStream(serverUniStream); EXPECT_TRUE( @@ -1736,9 +1736,9 @@ TEST_F(QuicStreamFunctionsTest, StreamExists) { EXPECT_FALSE(conn.streamManager->streamExists(peerAutoOpened)); conn.streamManager->getStream(peerStream)->sendState = - StreamSendState::Closed_E; + StreamSendState::Closed; conn.streamManager->getStream(peerStream)->recvState = - StreamRecvState::Closed_E; + StreamRecvState::Closed; EXPECT_TRUE(conn.streamManager->streamExists(localStream)); EXPECT_TRUE(conn.streamManager->streamExists(localAutoOpened)); EXPECT_FALSE(conn.streamManager->streamExists(notOpenedLocal)); @@ -1768,9 +1768,9 @@ TEST_F(QuicStreamFunctionsTest, StreamLimitUpdates) { conn.streamManager->setStreamLimitWindowingFraction( conn.transportSettings.advertisedInitialMaxStreamsBidi); conn.streamManager->getStream(peerStream)->sendState = - StreamSendState::Closed_E; + StreamSendState::Closed; conn.streamManager->getStream(peerStream)->recvState = - StreamRecvState::Closed_E; + StreamRecvState::Closed; EXPECT_FALSE(conn.streamManager->streamExists(notOpenedPeer)); EXPECT_TRUE(conn.streamManager->streamExists(peerStream)); EXPECT_TRUE(conn.streamManager->streamExists(peerAutoOpened)); diff --git a/quic/state/test/QuicStreamManagerTest.cpp b/quic/state/test/QuicStreamManagerTest.cpp index 39bad1e5d..40e9c6cac 100644 --- a/quic/state/test/QuicStreamManagerTest.cpp +++ b/quic/state/test/QuicStreamManagerTest.cpp @@ -73,8 +73,8 @@ TEST_F(QuicStreamManagerTest, TestAppIdleCreateBidiStream) { EXPECT_CALL(*mockController, setAppIdle(true, _)); // Force transition to closed state - stream.value()->sendState = StreamSendState::Closed_E; - stream.value()->recvState = StreamRecvState::Closed_E; + stream.value()->sendState = StreamSendState::Closed; + stream.value()->recvState = StreamRecvState::Closed; manager.removeClosedStream(stream.value()->id); EXPECT_TRUE(manager.isAppIdle()); EXPECT_EQ(manager.getStream(id), nullptr); @@ -89,8 +89,8 @@ TEST_F(QuicStreamManagerTest, TestAppIdleCreateUnidiStream) { // Force transition to closed state EXPECT_CALL(*mockController, setAppIdle(true, _)); - stream.value()->sendState = StreamSendState::Closed_E; - stream.value()->recvState = StreamRecvState::Closed_E; + stream.value()->sendState = StreamSendState::Closed; + stream.value()->recvState = StreamRecvState::Closed; manager.removeClosedStream(stream.value()->id); EXPECT_TRUE(manager.isAppIdle()); } @@ -170,8 +170,8 @@ TEST_F(QuicStreamManagerTest, TestAppIdleClosePeerStream) { EXPECT_CALL(*mockController, setAppIdle(true, _)); // Force transition to closed state - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; manager.removeClosedStream(stream->id); EXPECT_TRUE(manager.isAppIdle()); EXPECT_EQ(manager.getStream(id), nullptr); @@ -191,8 +191,8 @@ TEST_F(QuicStreamManagerTest, TestAppIdleCloseControlStream) { EXPECT_TRUE(manager.isAppIdle()); // Force transition to closed state - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; manager.removeClosedStream(stream->id); EXPECT_TRUE(manager.isAppIdle()); } @@ -209,12 +209,12 @@ TEST_F(QuicStreamManagerTest, StreamLimitWindowedUpdate) { } for (int i = 0; i < 25; i++) { auto stream = manager.getStream(i * detail::kStreamIncrement); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; manager.removeClosedStream(stream->id); stream = manager.getStream(2 + i * detail::kStreamIncrement); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; manager.removeClosedStream(stream->id); } auto update = manager.remoteBidirectionalStreamLimitUpdate(); @@ -238,8 +238,8 @@ TEST_F(QuicStreamManagerTest, StreamLimitNoWindowedUpdate) { } for (int i = 0; i < 24; i++) { auto stream = manager.getStream(i * detail::kStreamIncrement); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; manager.removeClosedStream(stream->id); } auto update = manager.remoteBidirectionalStreamLimitUpdate(); @@ -256,8 +256,8 @@ TEST_F(QuicStreamManagerTest, StreamLimitManyWindowedUpdate) { } for (int i = 0; i < 50; i++) { auto stream = manager.getStream(i * detail::kStreamIncrement); - stream->sendState = StreamSendState::Closed_E; - stream->recvState = StreamRecvState::Closed_E; + stream->sendState = StreamSendState::Closed; + stream->recvState = StreamRecvState::Closed; manager.removeClosedStream(stream->id); } auto update = manager.remoteBidirectionalStreamLimitUpdate();