From a396f623356dbde1219a2951ec3add32c65ef5af Mon Sep 17 00:00:00 2001 From: TJ Yin Date: Wed, 26 Feb 2020 08:37:00 -0800 Subject: [PATCH] Replace folly::Optional::hasValue() by has_value() Differential Revision: D19882830 fbshipit-source-id: 031217f9890351022bc8d171f0ccd7e045dd6972 --- quic/api/QuicPacketScheduler.cpp | 2 +- quic/api/QuicTransportBase.cpp | 4 ++-- quic/api/QuicTransportFunctions.cpp | 8 +++---- quic/api/test/QuicPacketSchedulerTest.cpp | 8 +++---- quic/api/test/QuicTransportBaseTest.cpp | 16 ++++++------- quic/api/test/QuicTransportFunctionsTest.cpp | 12 +++++----- quic/api/test/QuicTransportTest.cpp | 2 +- quic/client/QuicClientTransport.cpp | 4 ++-- .../handshake/test/ClientHandshakeTest.cpp | 12 +++++----- .../test/FizzClientExtensionsTest.cpp | 4 ++-- quic/client/test/QuicClientTransportTest.cpp | 10 ++++---- quic/codec/Decode.cpp | 2 +- quic/codec/QuicPacketRebuilder.cpp | 6 ++--- quic/codec/test/DecodeTest.cpp | 4 ++-- quic/codec/test/QuicIntegerTest.cpp | 4 ++-- quic/codec/test/QuicPacketBuilderTest.cpp | 4 ++-- quic/codec/test/QuicPacketRebuilderTest.cpp | 14 +++++------ quic/codec/test/QuicReadCodecTest.cpp | 2 +- quic/codec/test/QuicWriteCodecTest.cpp | 12 +++++----- quic/congestion_control/Bbr.cpp | 6 ++--- quic/congestion_control/BbrRttSampler.cpp | 2 +- quic/congestion_control/Copa.cpp | 12 +++++----- quic/congestion_control/NewReno.cpp | 8 +++---- quic/congestion_control/QuicCubic.cpp | 23 ++++++++++--------- .../QuicHappyEyeballsFunctions.cpp | 6 ++--- quic/logging/FileQLogger.cpp | 6 ++--- quic/loss/test/QuicLossFunctionsTest.cpp | 4 ++-- quic/samples/echo/EchoHandler.h | 2 +- quic/server/QuicServerTransport.cpp | 4 ++-- quic/server/QuicServerWorker.cpp | 2 +- .../ServerTransportParametersExtension.h | 2 +- quic/server/handshake/test/AppTokenTest.cpp | 2 +- .../test/ServerTransportParametersTest.cpp | 8 +++---- quic/server/state/ServerStateMachine.cpp | 6 ++--- quic/server/test/QuicServerTest.cpp | 4 ++-- quic/server/test/QuicServerTransportTest.cpp | 17 +++++++------- quic/state/AckHandlers.cpp | 2 +- quic/state/PendingPathRateLimiter.cpp | 2 +- quic/state/QuicStreamManager.cpp | 6 ++--- quic/state/StreamData.h | 3 ++- .../stream/test/StreamStateMachineTest.cpp | 2 +- quic/state/test/AckHandlersTest.cpp | 4 ++-- quic/state/test/QPRFunctionsTest.cpp | 18 +++++++-------- quic/state/test/QuicStateFunctionsTest.cpp | 2 +- 44 files changed, 143 insertions(+), 140 deletions(-) diff --git a/quic/api/QuicPacketScheduler.cpp b/quic/api/QuicPacketScheduler.cpp index 113e3dcd6..a0e90944f 100644 --- a/quic/api/QuicPacketScheduler.cpp +++ b/quic/api/QuicPacketScheduler.cpp @@ -312,7 +312,7 @@ bool StreamFrameScheduler::writeNextStreamFrame( std::min(getSendStreamFlowControlBytesWire(*stream), connWritableBytes); uint64_t bufferLen = stream->writeBuffer.chainLength(); bool canWriteFin = - stream->finalWriteOffset.hasValue() && bufferLen <= flowControlLen; + stream->finalWriteOffset.has_value() && bufferLen <= flowControlLen; auto dataLen = writeStreamFrameHeader( builder, stream->id, diff --git a/quic/api/QuicTransportBase.cpp b/quic/api/QuicTransportBase.cpp index c675c4767..26153b7e0 100644 --- a/quic/api/QuicTransportBase.cpp +++ b/quic/api/QuicTransportBase.cpp @@ -137,7 +137,7 @@ bool QuicTransportBase::replaySafe() const { } bool QuicTransportBase::error() const { - return conn_->localConnectionError.hasValue(); + return conn_->localConnectionError.has_value(); } void QuicTransportBase::close( @@ -1457,7 +1457,7 @@ void QuicTransportBase::processCallbacksAfterNetworkData() { cancelDeliveryCallbacksForStream(pendingResetIt->first); } auto deliverableStreamId = conn_->streamManager->popDeliverable(); - while (closeState_ == CloseState::OPEN && deliverableStreamId.hasValue()) { + while (closeState_ == CloseState::OPEN && deliverableStreamId.has_value()) { auto streamId = *deliverableStreamId; auto stream = conn_->streamManager->getStream(streamId); // stream shouldn't be cleaned as long as it's still on deliveryList diff --git a/quic/api/QuicTransportFunctions.cpp b/quic/api/QuicTransportFunctions.cpp index 4c7252d86..c41aa6f61 100644 --- a/quic/api/QuicTransportFunctions.cpp +++ b/quic/api/QuicTransportFunctions.cpp @@ -356,7 +356,7 @@ void updateConnection( if (resetIter != conn.pendingEvents.resets.end()) { conn.pendingEvents.resets.erase(resetIter); } else { - DCHECK(packetEvent.hasValue()) + DCHECK(packetEvent.has_value()) << " reset missing from pendingEvents for non-clone packet"; } break; @@ -403,7 +403,7 @@ void updateConnection( const QuicSimpleFrame& simpleFrame = *frame.asQuicSimpleFrame(); retransmittable = true; // We don't want this triggered for cloned frames. - if (!packetEvent.hasValue()) { + if (!packetEvent.has_value()) { updateSimpleFrameOnPacketSent(conn, simpleFrame); } break; @@ -456,8 +456,8 @@ void updateConnection( pkt.isAppLimited = conn.congestionController ? conn.congestionController->isAppLimited() : false; - if (conn.lossState.lastAckedTime.hasValue() && - conn.lossState.lastAckedPacketSentTime.hasValue()) { + if (conn.lossState.lastAckedTime.has_value() && + conn.lossState.lastAckedPacketSentTime.has_value()) { pkt.lastAckedPacketInfo.emplace( *conn.lossState.lastAckedPacketSentTime, *conn.lossState.lastAckedTime, diff --git a/quic/api/test/QuicPacketSchedulerTest.cpp b/quic/api/test/QuicPacketSchedulerTest.cpp index 50392acdd..e450a06b4 100644 --- a/quic/api/test/QuicPacketSchedulerTest.cpp +++ b/quic/api/test/QuicPacketSchedulerTest.cpp @@ -337,7 +337,7 @@ TEST_F(QuicPacketSchedulerTest, CloningSchedulerTest) { conn.ackStates.appDataAckState.largestAckedByPeer); auto result = cloningScheduler.scheduleFramesForPacket( std::move(builder), kDefaultUDPSendPacketLen); - EXPECT_TRUE(result.first.hasValue() && result.second.hasValue()); + EXPECT_TRUE(result.first.has_value() && result.second.has_value()); EXPECT_EQ(packetNum, *result.first); } @@ -383,7 +383,7 @@ TEST_F(QuicPacketSchedulerTest, WriteOnlyOutstandingPacketsTest) { auto result = cloningScheduler.scheduleFramesForPacket( std::move(regularBuilder), kDefaultUDPSendPacketLen); - EXPECT_TRUE(result.first.hasValue() && result.second.hasValue()); + EXPECT_TRUE(result.first.has_value() && result.second.has_value()); EXPECT_EQ(packetNum, *result.first); // written packet (result.second) should not have any frame in the builder auto& writtenPacket = *result.second; @@ -437,7 +437,7 @@ TEST_F(QuicPacketSchedulerTest, DoNotCloneProcessedClonedPacket) { conn.ackStates.initialAckState.largestAckedByPeer); auto result = cloningScheduler.scheduleFramesForPacket( std::move(builder), kDefaultUDPSendPacketLen); - EXPECT_TRUE(result.first.hasValue() && result.second.hasValue()); + EXPECT_TRUE(result.first.has_value() && result.second.has_value()); EXPECT_EQ(expected, *result.first); } @@ -482,7 +482,7 @@ TEST_F(QuicPacketSchedulerTest, DoNotCloneHandshake) { conn.ackStates.appDataAckState.largestAckedByPeer); auto result = cloningScheduler.scheduleFramesForPacket( std::move(builder), kDefaultUDPSendPacketLen); - EXPECT_TRUE(result.first.hasValue() && result.second.hasValue()); + EXPECT_TRUE(result.first.has_value() && result.second.has_value()); EXPECT_EQ(expected, *result.first); } diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp index c6f5b4392..315c50b5d 100644 --- a/quic/api/test/QuicTransportBaseTest.cpp +++ b/quic/api/test/QuicTransportBaseTest.cpp @@ -1491,17 +1491,17 @@ TEST_F(QuicTransportImplTest, AsyncStreamFlowControlWrite) { auto stream = transport->createBidirectionalStream().value(); auto streamState = transport->transportConn->streamManager->getStream(stream); transport->setServerConnectionId(); - EXPECT_FALSE(streamState->latestMaxStreamDataPacket.hasValue()); + EXPECT_FALSE(streamState->latestMaxStreamDataPacket.has_value()); transport->writeLooper()->stop(); streamState->flowControlState.advertisedMaxOffset = 0; // Easier to calculate transport->setStreamFlowControlWindow(stream, 4000); EXPECT_EQ(0, streamState->flowControlState.advertisedMaxOffset); - EXPECT_FALSE(streamState->latestMaxStreamDataPacket.hasValue()); + EXPECT_FALSE(streamState->latestMaxStreamDataPacket.has_value()); // Loop it: EXPECT_TRUE(transport->writeLooper()->isRunning()); transport->writeLooper()->runLoopCallback(); EXPECT_EQ(4000, streamState->flowControlState.advertisedMaxOffset); - EXPECT_TRUE(streamState->latestMaxStreamDataPacket.hasValue()); + EXPECT_TRUE(streamState->latestMaxStreamDataPacket.has_value()); } TEST_F(QuicTransportImplTest, ExceptionInWriteLooperDoesNotCrash) { @@ -2242,7 +2242,7 @@ TEST_F(QuicTransportImplTest, SendDataExpired) { EXPECT_EQ(res.hasError(), false); auto newOffsetOpt = res.value(); - EXPECT_EQ(newOffsetOpt.hasValue(), true); + EXPECT_EQ(newOffsetOpt.has_value(), true); EXPECT_EQ(newOffsetOpt.value(), 5); EXPECT_EQ(streamState->minimumRetransmittableOffset, 5); @@ -2252,7 +2252,7 @@ TEST_F(QuicTransportImplTest, SendDataExpired) { res = transport->sendDataExpired(stream1, 3); EXPECT_EQ(res.hasError(), false); newOffsetOpt = res.value(); - EXPECT_EQ(newOffsetOpt.hasValue(), false); + EXPECT_EQ(newOffsetOpt.has_value(), false); EXPECT_EQ(streamState->minimumRetransmittableOffset, 5); // Expect minimumRetransmittableOffset be set to 10 @@ -2260,7 +2260,7 @@ TEST_F(QuicTransportImplTest, SendDataExpired) { res = transport->sendDataExpired(stream1, 11); EXPECT_EQ(res.hasError(), false); newOffsetOpt = res.value(); - EXPECT_EQ(newOffsetOpt.hasValue(), true); + EXPECT_EQ(newOffsetOpt.has_value(), true); EXPECT_EQ(newOffsetOpt.value(), 10); EXPECT_EQ( streamState->minimumRetransmittableOffset, @@ -2444,7 +2444,7 @@ TEST_F(QuicTransportImplTest, SendDataRejected) { auto res = transport->sendDataRejected(stream1, 5); EXPECT_EQ(res.hasError(), false); auto newOffsetOpt = res.value(); - EXPECT_EQ(newOffsetOpt.hasValue(), true); + EXPECT_EQ(newOffsetOpt.has_value(), true); EXPECT_EQ(newOffsetOpt.value(), 5); EXPECT_EQ(streamState->currentReceiveOffset, 5); @@ -2452,7 +2452,7 @@ TEST_F(QuicTransportImplTest, SendDataRejected) { res = transport->sendDataRejected(stream1, 3); EXPECT_EQ(res.hasError(), false); newOffsetOpt = res.value(); - EXPECT_EQ(newOffsetOpt.hasValue(), false); + EXPECT_EQ(newOffsetOpt.has_value(), false); EXPECT_EQ(streamState->currentReceiveOffset, 5); transport.reset(); diff --git a/quic/api/test/QuicTransportFunctionsTest.cpp b/quic/api/test/QuicTransportFunctionsTest.cpp index e928c7d08..42521010b 100644 --- a/quic/api/test/QuicTransportFunctionsTest.cpp +++ b/quic/api/test/QuicTransportFunctionsTest.cpp @@ -826,7 +826,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithBytesStats) { getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake) ->totalBytesSent); EXPECT_TRUE(getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake) - ->lastAckedPacketInfo.hasValue()); + ->lastAckedPacketInfo.has_value()); EXPECT_EQ( currentTime - 123s, getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake) @@ -933,7 +933,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionStreamWindowUpdate) { EXPECT_EQ(frame->maximumData, 0); EXPECT_EQ(packetNum, *stream->latestMaxStreamDataPacket); - EXPECT_FALSE(conn->latestMaxDataPacket.hasValue()); + EXPECT_FALSE(conn->latestMaxDataPacket.has_value()); } TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionConnWindowUpdate) { @@ -965,7 +965,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionConnWindowUpdate) { auto frame = static_cast(event->frames[0].get()); EXPECT_EQ(frame->maximumData, conn->flowControlState.advertisedMaxOffset); - EXPECT_FALSE(stream->latestMaxStreamDataPacket.hasValue()); + EXPECT_FALSE(stream->latestMaxStreamDataPacket.has_value()); EXPECT_EQ(packetNum, *conn->latestMaxDataPacket); } @@ -1550,10 +1550,10 @@ TEST_F(QuicTransportFunctionsTest, ProbingNotWriteOtherFrames) { EXPECT_EQ(stream1->currentWriteOffset, currentStreamWriteOffset); EXPECT_TRUE(stream1->retransmissionBuffer.empty()); // No Ack scheduled: - EXPECT_FALSE(conn->ackStates.initialAckState.largestAckScheduled.hasValue()); + EXPECT_FALSE(conn->ackStates.initialAckState.largestAckScheduled.has_value()); EXPECT_FALSE( - conn->ackStates.handshakeAckState.largestAckScheduled.hasValue()); - EXPECT_FALSE(conn->ackStates.appDataAckState.largestAckScheduled.hasValue()); + conn->ackStates.handshakeAckState.largestAckScheduled.has_value()); + EXPECT_FALSE(conn->ackStates.appDataAckState.largestAckScheduled.has_value()); // Pending resets are still here: EXPECT_NE( conn->pendingEvents.resets.end(), diff --git a/quic/api/test/QuicTransportTest.cpp b/quic/api/test/QuicTransportTest.cpp index 8ae4adce1..fafa2e2d5 100644 --- a/quic/api/test/QuicTransportTest.cpp +++ b/quic/api/test/QuicTransportTest.cpp @@ -1768,7 +1768,7 @@ TEST_F(QuicTransportTest, FlowControlCallbacks) { SocketAddress("::1", 10000), NetworkData(IOBuf::copyBuffer("fake data"), Clock::now())); - EXPECT_FALSE(conn.streamManager->popFlowControlUpdated().hasValue()); + EXPECT_FALSE(conn.streamManager->popFlowControlUpdated().has_value()); } TEST_F(QuicTransportTest, DeliveryCallbackClosesClosedTransport) { diff --git a/quic/client/QuicClientTransport.cpp b/quic/client/QuicClientTransport.cpp index 5b287dfc8..158ed8bcd 100644 --- a/quic/client/QuicClientTransport.cpp +++ b/quic/client/QuicClientTransport.cpp @@ -957,7 +957,7 @@ void QuicClientTransport::removePsk() { void QuicClientTransport::onNewCachedPsk( fizz::client::NewCachedPsk& newCachedPsk) noexcept { - DCHECK(conn_->version.hasValue()); + DCHECK(conn_->version.has_value()); DCHECK(serverInitialParamsSet_); if (!pskCache_ || !hostname_) { @@ -1216,7 +1216,7 @@ void QuicClientTransport::onNotifyDataAvailable( if (networkData.packets.empty()) { return; } - DCHECK(server.hasValue()); + DCHECK(server.has_value()); // TODO: we can get better receive time accuracy than this, with // SO_TIMESTAMP or SIOCGSTAMP. auto packetReceiveTime = Clock::now(); diff --git a/quic/client/handshake/test/ClientHandshakeTest.cpp b/quic/client/handshake/test/ClientHandshakeTest.cpp index e56284945..c495869cd 100644 --- a/quic/client/handshake/test/ClientHandshakeTest.cpp +++ b/quic/client/handshake/test/ClientHandshakeTest.cpp @@ -285,7 +285,7 @@ TEST_F(ClientHandshakeTest, TestHandshakeSuccess) { serverClientRound(); expectHandshakeCipher(true); - EXPECT_FALSE(zeroRttRejected.hasValue()); + EXPECT_FALSE(zeroRttRejected.has_value()); EXPECT_EQ(handshake->getPhase(), ClientHandshake::Phase::OneRttKeysDerived); clientServerRound(); @@ -296,7 +296,7 @@ TEST_F(ClientHandshakeTest, TestHandshakeSuccess) { handshake->onRecvOneRttProtectedData(); EXPECT_EQ(handshake->getPhase(), ClientHandshake::Phase::Established); - EXPECT_FALSE(zeroRttRejected.hasValue()); + EXPECT_FALSE(zeroRttRejected.has_value()); EXPECT_TRUE(handshakeSuccess); } @@ -313,7 +313,7 @@ TEST_F(ClientHandshakeTest, TestNoErrorAfterAppClose) { // RTT 1/2 server -> client EXPECT_NO_THROW(serverClientRound()); expectOneRttCipher(true); - EXPECT_FALSE(zeroRttRejected.hasValue()); + EXPECT_FALSE(zeroRttRejected.has_value()); EXPECT_TRUE(handshakeSuccess); } @@ -332,7 +332,7 @@ TEST_F(ClientHandshakeTest, TestAppBytesInterpretedAsHandshake) { // RTT 1/2 server -> client serverClientRound(); expectOneRttCipher(true); - EXPECT_FALSE(zeroRttRejected.hasValue()); + EXPECT_FALSE(zeroRttRejected.has_value()); EXPECT_TRUE(handshakeSuccess); } @@ -428,7 +428,7 @@ TEST_F(ClientHandshakeHRRTest, TestFullHRR) { clientServerRound(); expectOneRttCipher(true); EXPECT_EQ(handshake->getPhase(), ClientHandshake::Phase::OneRttKeysDerived); - EXPECT_FALSE(zeroRttRejected.hasValue()); + EXPECT_FALSE(zeroRttRejected.has_value()); EXPECT_TRUE(handshakeSuccess); } @@ -494,7 +494,7 @@ TEST_F(ClientHandshakeZeroRttTest, TestZeroRttSuccess) { serverClientRound(); expectHandshakeCipher(true); EXPECT_EQ(handshake->getPhase(), ClientHandshake::Phase::OneRttKeysDerived); - EXPECT_FALSE(zeroRttRejected.hasValue()); + EXPECT_FALSE(zeroRttRejected.has_value()); expectZeroRttCipher(true, true); clientServerRound(); handshake->onRecvOneRttProtectedData(); diff --git a/quic/client/handshake/test/FizzClientExtensionsTest.cpp b/quic/client/handshake/test/FizzClientExtensionsTest.cpp index c4e3a6d75..79d302299 100644 --- a/quic/client/handshake/test/FizzClientExtensionsTest.cpp +++ b/quic/client/handshake/test/FizzClientExtensionsTest.cpp @@ -47,7 +47,7 @@ TEST(FizzClientHandshakeTest, TestGetChloExtensions) { EXPECT_EQ(extensions.size(), 1); auto serverParams = getExtension(extensions); - EXPECT_TRUE(serverParams.hasValue()); + EXPECT_TRUE(serverParams.has_value()); } TEST(FizzClientHandshakeTest, TestOnEE) { @@ -122,7 +122,7 @@ TEST(FizzClientHandshakeTest, TestGetChloExtensionsCustomParams) { EXPECT_EQ(extensions.size(), 1); auto serverParams = getExtension(extensions); - EXPECT_TRUE(serverParams.hasValue()); + EXPECT_TRUE(serverParams.has_value()); // check to see that the custom parameters are present auto it1 = std::find_if( diff --git a/quic/client/test/QuicClientTransportTest.cpp b/quic/client/test/QuicClientTransportTest.cpp index 78dd81a01..25cb129e5 100644 --- a/quic/client/test/QuicClientTransportTest.cpp +++ b/quic/client/test/QuicClientTransportTest.cpp @@ -931,8 +931,8 @@ TEST_P(QuicClientTransportIntegrationTest, TestStatelessResetToken) { eventbase_.loopForever(); EXPECT_TRUE(resetRecvd); - EXPECT_TRUE(token1.hasValue()); - EXPECT_TRUE(token2.hasValue()); + EXPECT_TRUE(token1.has_value()); + EXPECT_TRUE(token2.has_value()); EXPECT_EQ(token1.value(), token2.value()); } @@ -1412,8 +1412,8 @@ class QuicClientTransportTest : public Test { socketWrites.clear(); performFakeHandshake(); EXPECT_TRUE( - client->getConn().readCodec->getStatelessResetToken().hasValue()); - EXPECT_TRUE(client->getConn().statelessResetToken.hasValue()); + client->getConn().readCodec->getStatelessResetToken().has_value()); + EXPECT_TRUE(client->getConn().statelessResetToken.has_value()); } void setConnectionIds() { @@ -3634,7 +3634,7 @@ TEST_F( true)); deliverData(packet->coalesce()); EXPECT_NE(client->getConn().readCodec->getInitialCipher(), nullptr); - EXPECT_TRUE(client->getConn().readCodec->getHandshakeDoneTime().hasValue()); + EXPECT_TRUE(client->getConn().readCodec->getHandshakeDoneTime().has_value()); } TEST_F(QuicClientTransportAfterStartTest, IdleTimerResetOnRecvNewData) { diff --git a/quic/codec/Decode.cpp b/quic/codec/Decode.cpp index ea5c373d2..bfe518cb8 100644 --- a/quic/codec/Decode.cpp +++ b/quic/codec/Decode.cpp @@ -346,7 +346,7 @@ ReadStreamFrame decodeStreamFrame( } } Buf data; - if (dataLength.hasValue()) { + if (dataLength.has_value()) { if (cursor.totalLength() < dataLength->first) { throw QuicTransportException( "Length mismatch", diff --git a/quic/codec/QuicPacketRebuilder.cpp b/quic/codec/QuicPacketRebuilder.cpp index 20e2229a8..ead8d8784 100644 --- a/quic/codec/QuicPacketRebuilder.cpp +++ b/quic/codec/QuicPacketRebuilder.cpp @@ -67,7 +67,7 @@ folly::Optional PacketRebuilder::rebuildFromPacket( } AckFrameMetaData meta(ackBlocks, ackFrame.ackDelay, ackDelayExponent); auto ackWriteResult = writeAckFrame(meta, builder_); - writeSuccess = ackWriteResult.hasValue(); + writeSuccess = ackWriteResult.has_value(); break; } case QuicWriteFrame::Type::WriteStreamFrame_E: { @@ -84,7 +84,7 @@ folly::Optional PacketRebuilder::rebuildFromPacket( bufferLen, bufferLen, streamFrame.fin); - bool ret = dataLen.hasValue() && *dataLen == streamFrame.len; + bool ret = dataLen.has_value() && *dataLen == streamFrame.len; if (ret) { writeStreamFrameData(builder_, std::move(streamData), *dataLen); notPureAck = true; @@ -120,7 +120,7 @@ folly::Optional PacketRebuilder::rebuildFromPacket( } auto cryptoWriteResult = writeCryptoFrame(cryptoFrame.offset, std::move(buf), builder_); - bool ret = cryptoWriteResult.hasValue() && + bool ret = cryptoWriteResult.has_value() && cryptoWriteResult->offset == cryptoFrame.offset && cryptoWriteResult->len == cryptoFrame.len; notPureAck |= ret; diff --git a/quic/codec/test/DecodeTest.cpp b/quic/codec/test/DecodeTest.cpp index c46930536..36d680e99 100644 --- a/quic/codec/test/DecodeTest.cpp +++ b/quic/codec/test/DecodeTest.cpp @@ -137,7 +137,7 @@ TEST_F(DecodeTest, VersionNegotiationPacketDecodeTest) { AckStates ackStates; auto packetQueue = bufToQueue(std::move(packet.second)); auto versionPacket = codec->tryParsingVersionNegotiation(packetQueue); - ASSERT_TRUE(versionPacket.hasValue()); + ASSERT_TRUE(versionPacket.has_value()); EXPECT_EQ(versionPacket->destinationConnectionId, destCid); EXPECT_EQ(versionPacket->sourceConnectionId, srcCid); EXPECT_EQ(versionPacket->versions.size(), versions.size()); @@ -159,7 +159,7 @@ TEST_F(DecodeTest, DifferentCIDLength) { AckStates ackStates; auto packetQueue = bufToQueue(std::move(packet.second)); auto versionPacket = codec->tryParsingVersionNegotiation(packetQueue); - ASSERT_TRUE(versionPacket.hasValue()); + ASSERT_TRUE(versionPacket.has_value()); EXPECT_EQ(versionPacket->sourceConnectionId, sourceConnectionId); EXPECT_EQ(versionPacket->destinationConnectionId, destinationConnectionId); EXPECT_EQ(versionPacket->versions.size(), versions.size()); diff --git a/quic/codec/test/QuicIntegerTest.cpp b/quic/codec/test/QuicIntegerTest.cpp index 4327d1fbc..55b5d5eba 100644 --- a/quic/codec/test/QuicIntegerTest.cpp +++ b/quic/codec/test/QuicIntegerTest.cpp @@ -43,7 +43,7 @@ TEST_P(QuicIntegerDecodeTest, DecodeTrim) { auto originalLength = cursor.length(); auto decodedValue = decodeQuicInteger(cursor); if (GetParam().error || atMost != GetParam().encodedLength) { - EXPECT_FALSE(decodedValue.hasValue()); + EXPECT_FALSE(decodedValue.has_value()); EXPECT_EQ(cursor.length(), originalLength); } else { EXPECT_EQ(decodedValue->first, GetParam().decoded); @@ -62,7 +62,7 @@ TEST_P(QuicIntegerDecodeTest, DecodeAtMost) { auto originalLength = cursor.length(); auto decodedValue = decodeQuicInteger(cursor, atMost); if (GetParam().error || atMost != GetParam().encodedLength) { - EXPECT_FALSE(decodedValue.hasValue()); + EXPECT_FALSE(decodedValue.has_value()); EXPECT_EQ(cursor.length(), originalLength); } else { EXPECT_EQ(decodedValue->first, GetParam().decoded); diff --git a/quic/codec/test/QuicPacketBuilderTest.cpp b/quic/codec/test/QuicPacketBuilderTest.cpp index 392f11017..8c48143ed 100644 --- a/quic/codec/test/QuicPacketBuilderTest.cpp +++ b/quic/codec/test/QuicPacketBuilderTest.cpp @@ -103,7 +103,7 @@ TEST_F(QuicPacketBuilderTest, SimpleVersionNegotiationPacket) { auto decodedVersionNegotiationPacket = makeCodec(destConnId, QuicNodeType::Client) ->tryParsingVersionNegotiation(packetQueue); - ASSERT_TRUE(decodedVersionNegotiationPacket.hasValue()); + ASSERT_TRUE(decodedVersionNegotiationPacket.has_value()); EXPECT_EQ(decodedVersionNegotiationPacket->sourceConnectionId, srcConnId); EXPECT_EQ( decodedVersionNegotiationPacket->destinationConnectionId, destConnId); @@ -174,7 +174,7 @@ TEST_F(QuicPacketBuilderTest, TooManyVersions) { auto packetQueue = bufToQueue(std::move(resultBuf)); auto decodedPacket = makeCodec(destConnId, QuicNodeType::Client) ->tryParsingVersionNegotiation(packetQueue); - ASSERT_TRUE(decodedPacket.hasValue()); + ASSERT_TRUE(decodedPacket.has_value()); EXPECT_EQ(decodedPacket->destinationConnectionId, destConnId); EXPECT_EQ(decodedPacket->sourceConnectionId, srcConnId); EXPECT_EQ(decodedPacket->versions, expectedWrittenVersions); diff --git a/quic/codec/test/QuicPacketRebuilderTest.cpp b/quic/codec/test/QuicPacketRebuilderTest.cpp index 674f2ea59..518ea656a 100644 --- a/quic/codec/test/QuicPacketRebuilderTest.cpp +++ b/quic/codec/test/QuicPacketRebuilderTest.cpp @@ -109,7 +109,7 @@ TEST_F(QuicPacketRebuilderTest, RebuildPacket) { kDefaultUDPSendPacketLen, std::move(shortHeader2), 0 /* largestAcked */); PacketRebuilder rebuilder(regularBuilder2, conn); auto outstanding = makeDummyOutstandingPacket(packet1.packet, 1000); - EXPECT_TRUE(rebuilder.rebuildFromPacket(outstanding).hasValue()); + EXPECT_TRUE(rebuilder.rebuildFromPacket(outstanding).has_value()); auto packet2 = std::move(regularBuilder2).buildPacket(); // rebuilder writes frames to regularBuilder2 EXPECT_EQ(packet1.packet.frames.size(), packet2.packet.frames.size()); @@ -221,7 +221,7 @@ TEST_F(QuicPacketRebuilderTest, RebuildAfterResetStream) { kDefaultUDPSendPacketLen, std::move(shortHeader2), 0 /* largestAcked */); PacketRebuilder rebuilder(regularBuilder2, conn); auto outstanding = makeDummyOutstandingPacket(packet1.packet, 1000); - EXPECT_FALSE(rebuilder.rebuildFromPacket(outstanding).hasValue()); + EXPECT_FALSE(rebuilder.rebuildFromPacket(outstanding).has_value()); } TEST_F(QuicPacketRebuilderTest, FinOnlyStreamRebuild) { @@ -249,7 +249,7 @@ TEST_F(QuicPacketRebuilderTest, FinOnlyStreamRebuild) { kDefaultUDPSendPacketLen, std::move(shortHeader2), 0 /* largestAcked */); PacketRebuilder rebuilder(regularBuilder2, conn); auto outstanding = makeDummyOutstandingPacket(packet1.packet, 2000); - EXPECT_TRUE(rebuilder.rebuildFromPacket(outstanding).hasValue()); + EXPECT_TRUE(rebuilder.rebuildFromPacket(outstanding).has_value()); auto packet2 = std::move(regularBuilder2).buildPacket(); EXPECT_EQ(packet1.packet.frames.size(), packet2.packet.frames.size()); EXPECT_TRUE( @@ -307,7 +307,7 @@ TEST_F(QuicPacketRebuilderTest, RebuildDataStreamAndEmptyCryptoStream) { kDefaultUDPSendPacketLen, std::move(shortHeader2), 0 /* largestAcked */); PacketRebuilder rebuilder(regularBuilder2, conn); auto outstanding = makeDummyOutstandingPacket(packet1.packet, 1000); - EXPECT_TRUE(rebuilder.rebuildFromPacket(outstanding).hasValue()); + EXPECT_TRUE(rebuilder.rebuildFromPacket(outstanding).has_value()); auto packet2 = std::move(regularBuilder2).buildPacket(); // rebuilder writes frames to regularBuilder2 EXPECT_EQ(packet1.packet.frames.size(), packet2.packet.frames.size() + 1); @@ -349,7 +349,7 @@ TEST_F(QuicPacketRebuilderTest, CannotRebuildEmptyCryptoStream) { kDefaultUDPSendPacketLen, std::move(shortHeader2), 0 /* largestAcked */); PacketRebuilder rebuilder(regularBuilder2, conn); auto outstanding = makeDummyOutstandingPacket(packet1.packet, 1000); - EXPECT_FALSE(rebuilder.rebuildFromPacket(outstanding).hasValue()); + EXPECT_FALSE(rebuilder.rebuildFromPacket(outstanding).has_value()); } TEST_F(QuicPacketRebuilderTest, CannotRebuild) { @@ -407,7 +407,7 @@ TEST_F(QuicPacketRebuilderTest, CannotRebuild) { 0 /* largestAcked */); PacketRebuilder rebuilder(regularBuilder2, conn); auto outstanding = makeDummyOutstandingPacket(packet1.packet, 1000); - EXPECT_FALSE(rebuilder.rebuildFromPacket(outstanding).hasValue()); + EXPECT_FALSE(rebuilder.rebuildFromPacket(outstanding).has_value()); } TEST_F(QuicPacketRebuilderTest, CloneCounter) { @@ -426,7 +426,7 @@ TEST_F(QuicPacketRebuilderTest, CloneCounter) { kDefaultUDPSendPacketLen, std::move(shortHeader2), 0 /* largestAcked */); PacketRebuilder rebuilder(regularBuilder2, conn); rebuilder.rebuildFromPacket(outstandingPacket); - EXPECT_TRUE(outstandingPacket.associatedEvent.hasValue()); + EXPECT_TRUE(outstandingPacket.associatedEvent.has_value()); EXPECT_EQ(1, conn.outstandingClonedPacketsCount); } diff --git a/quic/codec/test/QuicReadCodecTest.cpp b/quic/codec/test/QuicReadCodecTest.cpp index 2cb5022c1..c66bf9e71 100644 --- a/quic/codec/test/QuicReadCodecTest.cpp +++ b/quic/codec/test/QuicReadCodecTest.cpp @@ -88,7 +88,7 @@ TEST_F(QuicReadCodecTest, VersionNegotiationPacketTest) { auto packetQueue = bufToQueue(std::move(packet.second)); auto versionNegotiationPacket = makeUnencryptedCodec()->tryParsingVersionNegotiation(packetQueue); - ASSERT_TRUE(versionNegotiationPacket.hasValue()); + ASSERT_TRUE(versionNegotiationPacket.has_value()); EXPECT_EQ(versionNegotiationPacket->destinationConnectionId, destConnId); EXPECT_EQ(versionNegotiationPacket->sourceConnectionId, srcConnId); EXPECT_EQ(versionNegotiationPacket->versions, versions); diff --git a/quic/codec/test/QuicWriteCodecTest.cpp b/quic/codec/test/QuicWriteCodecTest.cpp index 52cb652c2..444cd2114 100644 --- a/quic/codec/test/QuicWriteCodecTest.cpp +++ b/quic/codec/test/QuicWriteCodecTest.cpp @@ -358,7 +358,7 @@ TEST_F(QuicWriteCodecTest, WriteStreamNoSpaceForData) { // => 3 bytes auto dataLen = writeStreamFrameHeader(pktBuilder, streamId, offset, 10, 10, fin); - EXPECT_FALSE(dataLen.hasValue()); + EXPECT_FALSE(dataLen.has_value()); EXPECT_EQ(pktBuilder.remainingSpaceInPkt(), 3); } @@ -525,7 +525,7 @@ TEST_F(QuicWriteCodecTest, PacketOnlyHasSpaceForStreamHeader) { bool fin = true; auto dataLen = writeStreamFrameHeader(pktBuilder, streamId, offset, 20, 20, fin); - EXPECT_FALSE(dataLen.hasValue()); + EXPECT_FALSE(dataLen.has_value()); EXPECT_EQ(pktBuilder.remainingSpaceInPkt(), 2); } @@ -542,7 +542,7 @@ TEST_F(QuicWriteCodecTest, PacketOnlyHasSpaceForStreamHeaderWithFin) { bool fin = true; auto dataLen = writeStreamFrameHeader(pktBuilder, streamId, offset, 0, 0, fin); - ASSERT_TRUE(dataLen.hasValue()); + ASSERT_TRUE(dataLen.has_value()); EXPECT_EQ(*dataLen, 0); EXPECT_EQ(pktBuilder.remainingSpaceInPkt(), 0); } @@ -560,7 +560,7 @@ TEST_F(QuicWriteCodecTest, PacketNotEnoughSpaceForStreamHeaderWithFin) { bool fin = true; auto dataLen = writeStreamFrameHeader(pktBuilder, streamId, offset, 0, 0, fin); - ASSERT_FALSE(dataLen.hasValue()); + ASSERT_FALSE(dataLen.has_value()); EXPECT_EQ(pktBuilder.remainingSpaceInPkt(), 2); } @@ -622,7 +622,7 @@ TEST_F(QuicWriteCodecTest, AckFrameNotEnoughForAnything) { AckFrameMetaData ackMetadata(ackBlocks, 555us, kDefaultAckDelayExponent); auto result = writeAckFrame(ackMetadata, pktBuilder); - EXPECT_FALSE(result.hasValue()); + EXPECT_FALSE(result.has_value()); EXPECT_EQ(pktBuilder.remainingSpaceInPkt(), 4); } @@ -874,7 +874,7 @@ TEST_F(QuicWriteCodecTest, NoSpaceForAckBlockSection) { AckBlocks ackBlocks = {{1000, 1000}, {701, 900}, {501, 600}}; AckFrameMetaData ackMetadata(ackBlocks, 555us, kDefaultAckDelayExponent); auto ackFrameWriteResult = writeAckFrame(ackMetadata, pktBuilder); - EXPECT_FALSE(ackFrameWriteResult.hasValue()); + EXPECT_FALSE(ackFrameWriteResult.has_value()); } TEST_F(QuicWriteCodecTest, OnlyHasSpaceForFirstAckBlock) { diff --git a/quic/congestion_control/Bbr.cpp b/quic/congestion_control/Bbr.cpp index 8da22ab22..202651e9b 100644 --- a/quic/congestion_control/Bbr.cpp +++ b/quic/congestion_control/Bbr.cpp @@ -164,9 +164,9 @@ void BbrCongestionController::onPacketAckOrLoss( conn_.pacer->onPacketsLoss(); } } - if (ackEvent && ackEvent->largestAckedPacket.hasValue()) { + if (ackEvent && ackEvent->largestAckedPacket.has_value()) { CHECK(!ackEvent->ackedPackets.empty()); - onPacketAcked(*ackEvent, prevInflightBytes, lossEvent.hasValue()); + onPacketAcked(*ackEvent, prevInflightBytes, lossEvent.has_value()); } } @@ -197,7 +197,7 @@ void BbrCongestionController::onPacketAcked( } } if (inRecovery()) { - CHECK(endOfRecovery_.hasValue()); + CHECK(endOfRecovery_.has_value()); if (newRoundTrip && recoveryState_ != BbrCongestionController::RecoveryState::GROWTH) { recoveryState_ = BbrCongestionController::RecoveryState::GROWTH; diff --git a/quic/congestion_control/BbrRttSampler.cpp b/quic/congestion_control/BbrRttSampler.cpp index e16eeaeb9..885b2d109 100644 --- a/quic/congestion_control/BbrRttSampler.cpp +++ b/quic/congestion_control/BbrRttSampler.cpp @@ -22,7 +22,7 @@ std::chrono::microseconds BbrRttSampler::minRtt() const noexcept { bool BbrRttSampler::newRttSample( std::chrono::microseconds rttSample, TimePoint sampledTime) noexcept { - rttSampleExpired_ = minRttTimestamp_.hasValue() + rttSampleExpired_ = minRttTimestamp_.has_value() ? sampledTime > *minRttTimestamp_ + expiration_ : false; if (rttSampleExpired_ || minRtt_ > rttSample) { diff --git a/quic/congestion_control/Copa.cpp b/quic/congestion_control/Copa.cpp index 818d4916c..5301c4da9 100644 --- a/quic/congestion_control/Copa.cpp +++ b/quic/congestion_control/Copa.cpp @@ -28,7 +28,7 @@ Copa::Copa(QuicConnectionStateBase& conn) VLOG(10) << __func__ << " writable=" << getWritableBytes() << " cwnd=" << cwndBytes_ << " inflight=" << bytesInFlight_ << " " << conn_; - if (conn_.transportSettings.latencyFactor.hasValue()) { + if (conn_.transportSettings.latencyFactor.has_value()) { latencyFactor_ = conn_.transportSettings.latencyFactor.value(); } QUIC_TRACE(initcwnd, conn_, cwndBytes_); @@ -72,7 +72,7 @@ void Copa::onPacketSent(const OutstandingPacket& packet) { * has remained the same for three RTTs */ void Copa::checkAndUpdateDirection(const TimePoint ackTime) { - if (!velocityState_.lastCwndRecordTime.hasValue()) { + if (!velocityState_.lastCwndRecordTime.has_value()) { velocityState_.lastCwndRecordTime = ackTime; velocityState_.lastRecordedCwndBytes = cwndBytes_; return; @@ -133,14 +133,14 @@ void Copa::onPacketAckOrLoss( } QUIC_TRACE(copa_loss, conn_, cwndBytes_, bytesInFlight_); } - if (ack && ack->largestAckedPacket.hasValue()) { + if (ack && ack->largestAckedPacket.has_value()) { onPacketAcked(*ack); QUIC_TRACE(copa_ack, conn_, cwndBytes_, bytesInFlight_); } } void Copa::onPacketAcked(const AckEvent& ack) { - DCHECK(ack.largestAckedPacket.hasValue()); + DCHECK(ack.largestAckedPacket.has_value()); subtractAndCheckUnderflow(bytesInFlight_, ack.ackedBytes); minRTTFilter_.Update( conn_.lossState.lrtt, @@ -215,7 +215,7 @@ void Copa::onPacketAcked(const AckEvent& ack) { if (isSlowStart_) { // When a flow starts, Copa performs slow-start where // cwnd doubles once per RTT until current rate exceeds target rate". - if (!lastCwndDoubleTime_.hasValue()) { + if (!lastCwndDoubleTime_.has_value()) { lastCwndDoubleTime_ = ack.ackTime; } else if ( ack.ackTime - lastCwndDoubleTime_.value() > conn_.lossState.srtt) { @@ -276,7 +276,7 @@ void Copa::onPacketLoss(const LossEvent& loss) { conn_.qLogger->addCongestionMetricUpdate( bytesInFlight_, getCongestionWindow(), kCongestionPacketLoss); } - DCHECK(loss.largestLostPacketNum.hasValue()); + DCHECK(loss.largestLostPacketNum.has_value()); subtractAndCheckUnderflow(bytesInFlight_, loss.lostBytes); if (loss.persistentCongestion) { // TODO See if we should go to slowStart here diff --git a/quic/congestion_control/NewReno.cpp b/quic/congestion_control/NewReno.cpp index db2af58f4..d981e1cf1 100644 --- a/quic/congestion_control/NewReno.cpp +++ b/quic/congestion_control/NewReno.cpp @@ -49,7 +49,7 @@ void NewReno::onPacketSent(const OutstandingPacket& packet) { } void NewReno::onAckEvent(const AckEvent& ack) { - DCHECK(ack.largestAckedPacket.hasValue() && !ack.ackedPackets.empty()); + DCHECK(ack.largestAckedPacket.has_value() && !ack.ackedPackets.empty()); subtractAndCheckUnderflow(bytesInFlight_, ack.ackedBytes); VLOG(10) << __func__ << " writable=" << getWritableBytes() << " cwnd=" << cwndBytes_ << " inflight=" << bytesInFlight_ << " " @@ -93,7 +93,7 @@ void NewReno::onPacketAckOrLoss( // When we start to support pacing in NewReno, we need to call onPacketsLoss // on the pacer when there is loss. } - if (ackEvent && ackEvent->largestAckedPacket.hasValue()) { + if (ackEvent && ackEvent->largestAckedPacket.has_value()) { onAckEvent(*ackEvent); } // TODO: Pacing isn't supported with NewReno @@ -101,8 +101,8 @@ void NewReno::onPacketAckOrLoss( void NewReno::onPacketLoss(const LossEvent& loss) { DCHECK( - loss.largestLostPacketNum.hasValue() && - loss.largestLostSentTime.hasValue()); + loss.largestLostPacketNum.has_value() && + loss.largestLostSentTime.has_value()); subtractAndCheckUnderflow(bytesInFlight_, loss.lostBytes); if (!endOfRecovery_ || *endOfRecovery_ < *loss.largestLostSentTime) { endOfRecovery_ = Clock::now(); diff --git a/quic/congestion_control/QuicCubic.cpp b/quic/congestion_control/QuicCubic.cpp index 39ab99f80..9dd620022 100644 --- a/quic/congestion_control/QuicCubic.cpp +++ b/quic/congestion_control/QuicCubic.cpp @@ -95,8 +95,8 @@ void Cubic::onPacketSent(const OutstandingPacket& packet) { void Cubic::onPacketLoss(const LossEvent& loss) { quiescenceStart_ = folly::none; DCHECK( - loss.largestLostPacketNum.hasValue() && - loss.largestLostSentTime.hasValue()); + loss.largestLostPacketNum.has_value() && + loss.largestLostSentTime.has_value()); onRemoveBytesFromInflight(loss.lostBytes); // If the loss occurred past the endOfRecovery then we need to move the // endOfRecovery back and invoke the state machine, otherwise ignore the loss @@ -208,7 +208,7 @@ bool Cubic::isAppLimited() const noexcept { } bool Cubic::isAppIdle() const noexcept { - return quiescenceStart_.hasValue(); + return quiescenceStart_.has_value(); } void Cubic::updateTimeToOrigin() noexcept { @@ -355,7 +355,7 @@ void Cubic::onPacketAckOrLoss( conn_.pacer->onPacketsLoss(); } } - if (ackEvent && ackEvent->largestAckedPacket.hasValue()) { + if (ackEvent && ackEvent->largestAckedPacket.has_value()) { CHECK(!ackEvent->ackedPackets.empty()); onPacketAcked(*ackEvent); } @@ -365,7 +365,7 @@ void Cubic::onPacketAcked(const AckEvent& ack) { auto currentCwnd = cwndBytes_; DCHECK_LE(ack.ackedBytes, inflightBytes_); inflightBytes_ -= ack.ackedBytes; - if (recoveryState_.endOfRecovery.hasValue() && + if (recoveryState_.endOfRecovery.has_value() && *recoveryState_.endOfRecovery >= ack.largestAckedPacketSentTime) { QUIC_TRACE(fst_trace, conn_, "cubic_skip_ack"); if (conn_.qLogger) { @@ -393,7 +393,8 @@ void Cubic::onPacketAcked(const AckEvent& ack) { cwndBytes_ * pacingGain(), conn_.lossState.srtt); } if (cwndBytes_ == currentCwnd) { - QUIC_TRACE(fst_trace, conn_, "cwnd_no_change", quiescenceStart_.hasValue()); + QUIC_TRACE( + fst_trace, conn_, "cwnd_no_change", quiescenceStart_.has_value()); if (conn_.qLogger) { conn_.qLogger->addCongestionMetricUpdate( inflightBytes_, @@ -430,7 +431,7 @@ void Cubic::startHystartRttRound(TimePoint time) noexcept { } bool Cubic::isRecovered(TimePoint packetSentTime) noexcept { - CHECK(recoveryState_.endOfRecovery.hasValue()); + CHECK(recoveryState_.endOfRecovery.has_value()); return packetSentTime > *recoveryState_.endOfRecovery; } @@ -502,7 +503,7 @@ void Cubic::onPacketAckedInHystart(const AckEvent& ack) { cwndBytes_ >= kLowSsthreshInMss * conn_.udpSendPacketLen) { exitReason = Cubic::ExitReason::EXITPOINT; } - if (exitReason.hasValue()) { + if (exitReason.has_value()) { VLOG(15) << "Cubic exit slow start, reason = " << (*exitReason == Cubic::ExitReason::SSTHRESH ? "cwnd > ssthresh" @@ -568,7 +569,7 @@ void Cubic::onPacketAckedInHystart(const AckEvent& ack) { } } - if (!hystartState_.lastSampledRtt.hasValue() || + if (!hystartState_.lastSampledRtt.has_value() || (*hystartState_.lastSampledRtt >= std::chrono::microseconds::max() - kDelayIncreaseLowerBound)) { return; @@ -711,8 +712,8 @@ void Cubic::onPacketAckedInRecovery(const AckEvent& ack) { // lastMaxCwndBytes and lastReductionTime are only cleared when Hystart // transits to Steady. For state machine to be in FastRecovery, a Loss // should have happened, and set values to them. - DCHECK(steadyState_.lastMaxCwndBytes.hasValue()); - DCHECK(steadyState_.lastReductionTime.hasValue()); + DCHECK(steadyState_.lastMaxCwndBytes.has_value()); + DCHECK(steadyState_.lastReductionTime.has_value()); updateTimeToOrigin(); cwndBytes_ = calculateCubicCwnd(calculateCubicCwndDelta(ack.ackTime)); if (conn_.qLogger) { diff --git a/quic/happyeyeballs/QuicHappyEyeballsFunctions.cpp b/quic/happyeyeballs/QuicHappyEyeballsFunctions.cpp index 95bfd1126..0109e6c05 100644 --- a/quic/happyeyeballs/QuicHappyEyeballsFunctions.cpp +++ b/quic/happyeyeballs/QuicHappyEyeballsFunctions.cpp @@ -129,13 +129,13 @@ void happyEyeballsSetUpSocket( folly::AsyncUDPSocket::ErrMessageCallback* errMsgCallback, folly::AsyncUDPSocket::ReadCallback* readCallback, const folly::SocketOptionMap& options) { - auto sockFamily = localAddress.hasValue() ? localAddress->getFamily() - : peerAddress.getFamily(); + auto sockFamily = localAddress.has_value() ? localAddress->getFamily() + : peerAddress.getFamily(); applySocketOptions( socket, options, sockFamily, folly::SocketOptionKey::ApplyPos::PRE_BIND); socket.setReuseAddr(false); - if (localAddress.hasValue()) { + if (localAddress.has_value()) { socket.bind(*localAddress); } else if (peerAddress.getFamily() == AF_INET) { socket.bind(folly::SocketAddress("0.0.0.0", 0)); diff --git a/quic/logging/FileQLogger.cpp b/quic/logging/FileQLogger.cpp index 87cb95202..dcf092bc6 100644 --- a/quic/logging/FileQLogger.cpp +++ b/quic/logging/FileQLogger.cpp @@ -245,8 +245,8 @@ folly::dynamic FileQLogger::toDynamic() const { dynamicTrace["configuration"] = folly::dynamic::object("time_offset", 0)("time_units", kQLogTimeUnits); - std::string dcidStr = dcid.hasValue() ? dcid.value().hex() : ""; - std::string scidStr = scid.hasValue() ? scid.value().hex() : ""; + std::string dcidStr = dcid.has_value() ? dcid.value().hex() : ""; + std::string scidStr = scid.has_value() ? scid.value().hex() : ""; folly::dynamic commonFieldsObj = folly::dynamic::object; commonFieldsObj["reference_time"] = "0"; commonFieldsObj["dcid"] = dcidStr; @@ -297,7 +297,7 @@ void FileQLogger::addPathValidationEvent(bool success) { } void FileQLogger::outputLogsToFile(const std::string& path, bool prettyJson) { - if (!dcid.hasValue()) { + if (!dcid.has_value()) { LOG(ERROR) << "Error: No dcid found"; return; } diff --git a/quic/loss/test/QuicLossFunctionsTest.cpp b/quic/loss/test/QuicLossFunctionsTest.cpp index 640ad7303..bf8df052d 100644 --- a/quic/loss/test/QuicLossFunctionsTest.cpp +++ b/quic/loss/test/QuicLossFunctionsTest.cpp @@ -926,7 +926,7 @@ TEST_F(QuicLossFunctionsTest, LossTimePreemptsCryptoTimer) { PacketNumberSpace::Handshake); EXPECT_TRUE(lostPackets.empty()); EXPECT_TRUE( - conn->lossState.lossTimes[PacketNumberSpace::Handshake].hasValue()); + conn->lossState.lossTimes[PacketNumberSpace::Handshake].has_value()); EXPECT_EQ( expectedDelayUntilLost + sendTime, conn->lossState.lossTimes[PacketNumberSpace::Handshake].value()); @@ -949,7 +949,7 @@ TEST_F(QuicLossFunctionsTest, LossTimePreemptsCryptoTimer) { *conn, testingLossMarkFunc(lostPackets)); EXPECT_EQ(1, lostPackets.size()); EXPECT_FALSE( - conn->lossState.lossTimes[PacketNumberSpace::Handshake].hasValue()); + conn->lossState.lossTimes[PacketNumberSpace::Handshake].has_value()); EXPECT_TRUE(conn->outstandingPackets.empty()); } diff --git a/quic/samples/echo/EchoHandler.h b/quic/samples/echo/EchoHandler.h index d14e638ba..c92b8d9ea 100644 --- a/quic/samples/echo/EchoHandler.h +++ b/quic/samples/echo/EchoHandler.h @@ -134,7 +134,7 @@ class EchoHandler : public quic::QuicSocket::ConnectionCallback, LOG(ERROR) << "skip error=" << toString(skipRes.error()); } else { auto v = skipRes.value(); - if (v.hasValue()) { + if (v.has_value()) { LOG(INFO) << "new offset = " << v.value(); } else { LOG(INFO) << "new offset doesn't have value"; diff --git a/quic/server/QuicServerTransport.cpp b/quic/server/QuicServerTransport.cpp index 4cae6cb96..94bdfabf2 100644 --- a/quic/server/QuicServerTransport.cpp +++ b/quic/server/QuicServerTransport.cpp @@ -426,7 +426,7 @@ void QuicServerTransport::maybeIssueConnectionIds() { if (!conn_->transportSettings.disableMigration && !connectionIdsIssued_ && serverConn_->serverHandshakeLayer->isHandshakeDone()) { connectionIdsIssued_ = true; - CHECK(conn_->transportSettings.statelessResetTokenSecret.hasValue()); + CHECK(conn_->transportSettings.statelessResetTokenSecret.has_value()); // If the peer specifies that they have a limit of 1,000,000 connection ids // then only issue a small number at first, since the server still @@ -435,7 +435,7 @@ void QuicServerTransport::maybeIssueConnectionIds() { conn_->peerActiveConnectionIdLimit, kDefaultActiveConnectionIdLimit); for (size_t i = 0; i < maximumIdsToIssue; i++) { auto newConnIdData = serverConn_->createAndAddNewSelfConnId(); - if (!newConnIdData.hasValue()) { + if (!newConnIdData.has_value()) { return; } diff --git a/quic/server/QuicServerWorker.cpp b/quic/server/QuicServerWorker.cpp index 1bd6b653f..93a45621a 100644 --- a/quic/server/QuicServerWorker.cpp +++ b/quic/server/QuicServerWorker.cpp @@ -563,7 +563,7 @@ void QuicServerWorker::sendResetPacket( uint16_t maxResetPacketSize = std::min( std::max(kMinStatelessPacketSize, packetSize), kDefaultUDPSendPacketLen); - CHECK(transportSettings_.statelessResetTokenSecret.hasValue()); + CHECK(transportSettings_.statelessResetTokenSecret.has_value()); StatelessResetGenerator generator( *transportSettings_.statelessResetTokenSecret, getAddress().getFullyQualified()); diff --git a/quic/server/handshake/ServerTransportParametersExtension.h b/quic/server/handshake/ServerTransportParametersExtension.h index e446f06af..c019ffe73 100644 --- a/quic/server/handshake/ServerTransportParametersExtension.h +++ b/quic/server/handshake/ServerTransportParametersExtension.h @@ -57,7 +57,7 @@ class ServerTransportParametersExtension : public fizz::ServerExtensions { fizz::AlertDescription::missing_extension); } clientTransportParameters_ = std::move(clientParams); - if (!clientTransportParameters_->initial_version.hasValue()) { + if (!clientTransportParameters_->initial_version.has_value()) { negotiatedVersion_ = folly::none; } diff --git a/quic/server/handshake/test/AppTokenTest.cpp b/quic/server/handshake/test/AppTokenTest.cpp index 5006632da..6d28fe0fd 100644 --- a/quic/server/handshake/test/AppTokenTest.cpp +++ b/quic/server/handshake/test/AppTokenTest.cpp @@ -25,7 +25,7 @@ namespace test { void expectAppTokenEqual( const folly::Optional& decodedAppToken, const AppToken& appToken) { - EXPECT_TRUE(decodedAppToken.hasValue()); + EXPECT_TRUE(decodedAppToken.has_value()); EXPECT_EQ( decodedAppToken->transportParams.negotiated_version, diff --git a/quic/server/handshake/test/ServerTransportParametersTest.cpp b/quic/server/handshake/test/ServerTransportParametersTest.cpp index 5822ef0da..547c57b13 100644 --- a/quic/server/handshake/test/ServerTransportParametersTest.cpp +++ b/quic/server/handshake/test/ServerTransportParametersTest.cpp @@ -53,8 +53,8 @@ TEST(ServerTransportParametersTest, TestGetExtensions) { EXPECT_EQ(extensions.size(), 1); auto serverParams = getExtension(extensions); - EXPECT_TRUE(serverParams.hasValue()); - EXPECT_FALSE(serverParams->negotiated_version.hasValue()); + EXPECT_TRUE(serverParams.has_value()); + EXPECT_FALSE(serverParams->negotiated_version.has_value()); } TEST(ServerTransportParametersTest, TestGetExtensionsD18) { @@ -77,8 +77,8 @@ TEST(ServerTransportParametersTest, TestGetExtensionsD18) { EXPECT_EQ(extensions.size(), 1); auto serverParams = getExtension(extensions); - EXPECT_TRUE(serverParams.hasValue()); - EXPECT_TRUE(serverParams->negotiated_version.hasValue()); + EXPECT_TRUE(serverParams.has_value()); + EXPECT_TRUE(serverParams->negotiated_version.has_value()); folly::Optional tokWrapper = getStatelessResetTokenParameter(serverParams->parameters); diff --git a/quic/server/state/ServerStateMachine.cpp b/quic/server/state/ServerStateMachine.cpp index c7bd04f8f..567c62bc6 100644 --- a/quic/server/state/ServerStateMachine.cpp +++ b/quic/server/state/ServerStateMachine.cpp @@ -362,7 +362,7 @@ void onConnectionMigration( } ++conn.migrationState.numMigrations; - bool hasPendingPathChallenge = conn.pendingEvents.pathChallenge.hasValue(); + bool hasPendingPathChallenge = conn.pendingEvents.pathChallenge.has_value(); // Clear any pending path challenge frame that is not sent conn.pendingEvents.pathChallenge = folly::none; @@ -559,12 +559,12 @@ void onServerReadDataFromOpen( } CHECK(conn.connIdAlgo) << "ConnectionIdAlgo is not set."; - CHECK(!conn.serverConnectionId.hasValue()); + CHECK(!conn.serverConnectionId.has_value()); // serverConnIdParams must be set by the QuicServerTransport CHECK(conn.serverConnIdParams); auto newServerConnIdData = conn.createAndAddNewSelfConnId(); - CHECK(newServerConnIdData.hasValue()); + CHECK(newServerConnIdData.has_value()); conn.serverConnectionId = newServerConnIdData->connId; QUIC_STATS(conn.infoCallback, onStatelessReset); diff --git a/quic/server/test/QuicServerTest.cpp b/quic/server/test/QuicServerTest.cpp index 724c4d542..e3ee284f6 100644 --- a/quic/server/test/QuicServerTest.cpp +++ b/quic/server/test/QuicServerTest.cpp @@ -1922,7 +1922,7 @@ TEST_F(QuicServerTest, NetworkTestVersionNegotiation) { auto codec = std::make_unique(QuicNodeType::Server); auto packetQueue = bufToQueue(std::move(serverData)); auto versionPacket = codec->tryParsingVersionNegotiation(packetQueue); - ASSERT_TRUE(versionPacket.hasValue()); + ASSERT_TRUE(versionPacket.has_value()); EXPECT_EQ(versionPacket->destinationConnectionId, clientConnId); EXPECT_TRUE(testingObserver->observerCalled()); @@ -1965,7 +1965,7 @@ TEST_F(QuicServerTest, TestRejectNewConnections) { auto packetQueue = bufToQueue(std::move(serverData)); auto versionPacket = codec->tryParsingVersionNegotiation(packetQueue); - ASSERT_TRUE(versionPacket.hasValue()); + ASSERT_TRUE(versionPacket.has_value()); EXPECT_EQ(versionPacket->destinationConnectionId, clientConnId); EXPECT_EQ(versionPacket->sourceConnectionId, serverConnId); diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp index 6a387a197..061e868e2 100644 --- a/quic/server/test/QuicServerTransportTest.cpp +++ b/quic/server/test/QuicServerTransportTest.cpp @@ -469,11 +469,11 @@ class QuicServerTransportTest : public Test { EXPECT_NE(server->getConn().handshakeWriteHeaderCipher, nullptr); EXPECT_NE(server->getConn().readCodec->getHandshakeHeaderCipher(), nullptr); - EXPECT_FALSE(server->getConn().localConnectionError.hasValue()); + EXPECT_FALSE(server->getConn().localConnectionError.has_value()); EXPECT_EQ(server->getConn().version, QuicVersion::MVFST); EXPECT_EQ(server->getConn().serverConnIdParams->processId, 0); EXPECT_EQ(server->getConn().serverConnIdParams->workerId, 1); - EXPECT_TRUE(server->getConn().serverConnectionId.hasValue()); + EXPECT_TRUE(server->getConn().serverConnectionId.has_value()); EXPECT_EQ(server->getConn().selfConnectionIds.size(), 1); serverConnectionId = *server->getConn().serverConnectionId; EXPECT_EQ( @@ -542,7 +542,7 @@ class QuicServerTransportTest : public Test { *server->getConn().cryptoState, EncryptionLevel::Initial) ->readBuffer.empty()); EXPECT_NE(server->getConn().initialWriteCipher, nullptr); - EXPECT_FALSE(server->getConn().localConnectionError.hasValue()); + EXPECT_FALSE(server->getConn().localConnectionError.has_value()); verifyTransportParameters(kDefaultIdleTimeout); serverWrites.clear(); @@ -746,8 +746,9 @@ TEST_F(QuicServerTransportTest, TestReadMultipleStreams) { EXPECT_CALL(*transportInfoCb_, onNewQuicStream()).Times(2); // for x08, x0C deliverData(packetToBuf(packet)); - EXPECT_TRUE(server->getConn() - .ackStates.appDataAckState.largestRecvdPacketTime.hasValue()); + EXPECT_TRUE( + server->getConn() + .ackStates.appDataAckState.largestRecvdPacketTime.has_value()); EXPECT_EQ(server->getConn().ackStates.appDataAckState.acks.size(), 1); EXPECT_EQ( server->getConn().ackStates.appDataAckState.acks.front().start, @@ -1282,7 +1283,7 @@ TEST_F(QuicServerTransportTest, RecvRstStreamFrameNonexistClientStream) { deliverData(packetToBuf(packet)); auto stream = server->getNonConstConn().streamManager->getStream(streamId); - ASSERT_TRUE(stream->streamReadError.hasValue()); + ASSERT_TRUE(stream->streamReadError.has_value()); } TEST_F(QuicServerTransportTest, ReceiveRstStreamNonExistentAndOtherFrame) { @@ -1577,7 +1578,7 @@ TEST_F(QuicServerTransportTest, RecvStopSendingFrameAfterHalfCloseRemote) { ASSERT_TRUE(builder.canBuildPacket()); auto dataLen = writeStreamFrameHeader( builder, 0x00, stream->currentReadOffset, 0, 10, true); - ASSERT_TRUE(dataLen.hasValue()); + ASSERT_TRUE(dataLen.has_value()); ASSERT_EQ(*dataLen, 0); writeFrame(QuicSimpleFrame(stopSendingFrame), builder); auto packet = std::move(builder).buildPacket(); @@ -3598,7 +3599,7 @@ TEST_F( setupClientReadCodec(); recvClientHello(); - ASSERT_TRUE(server->getNonConstConn().writableBytesLimit.hasValue()); + ASSERT_TRUE(server->getNonConstConn().writableBytesLimit.has_value()); EXPECT_EQ( *server->getNonConstConn().writableBytesLimit, server->getConn().transportSettings.limitedCwndInMss * originalUdpSize); diff --git a/quic/state/AckHandlers.cpp b/quic/state/AckHandlers.cpp index 084eaa9b0..f113eca6b 100644 --- a/quic/state/AckHandlers.cpp +++ b/quic/state/AckHandlers.cpp @@ -187,7 +187,7 @@ void processAckFrame( DCHECK_GE(updatedOustandingPacketsCount, conn.outstandingClonedPacketsCount); auto lossEvent = handleAckForLoss(conn, lossVisitor, ack, pnSpace); if (conn.congestionController && - (ack.largestAckedPacket.hasValue() || lossEvent)) { + (ack.largestAckedPacket.has_value() || lossEvent)) { if (lossEvent) { DCHECK(lossEvent->largestLostSentTime && lossEvent->smallestLostSentTime); lossEvent->persistentCongestion = isPersistentCongestion( diff --git a/quic/state/PendingPathRateLimiter.cpp b/quic/state/PendingPathRateLimiter.cpp index e9a37e526..8ffc0e075 100644 --- a/quic/state/PendingPathRateLimiter.cpp +++ b/quic/state/PendingPathRateLimiter.cpp @@ -13,7 +13,7 @@ void PendingPathRateLimiter::onPacketSent(uint64_t sentBytes) { uint64_t PendingPathRateLimiter::currentCredit( TimePoint checkTime, std::chrono::microseconds rtt) noexcept { - if ((!lastChecked_.hasValue()) || (checkTime > *lastChecked_ + rtt)) { + if ((!lastChecked_.has_value()) || (checkTime > *lastChecked_ + rtt)) { lastChecked_ = checkTime; credit_ = maxCredit_; } diff --git a/quic/state/QuicStreamManager.cpp b/quic/state/QuicStreamManager.cpp index 2bdc80eb6..11a0618e7 100644 --- a/quic/state/QuicStreamManager.cpp +++ b/quic/state/QuicStreamManager.cpp @@ -476,7 +476,7 @@ void QuicStreamManager::updateLossStreams(QuicStreamState& stream) { void QuicStreamManager::updateReadableStreams(QuicStreamState& stream) { updateHolBlockedTime(stream); auto itr = readableStreams_.find(stream.id); - if (!stream.hasReadableData() && !stream.streamReadError.hasValue()) { + if (!stream.hasReadableData() && !stream.streamReadError.has_value()) { if (itr != readableStreams_.end()) { VLOG(10) << __func__ << " remove stream=" << stream.id << " " << stream.conn; @@ -494,7 +494,7 @@ void QuicStreamManager::updateReadableStreams(QuicStreamState& stream) { } void QuicStreamManager::updateWritableStreams(QuicStreamState& stream) { - if (stream.hasWritableData() && !stream.streamWriteError.hasValue()) { + if (stream.hasWritableData() && !stream.streamWriteError.has_value()) { stream.conn.streamManager->addWritable(stream); } else { stream.conn.streamManager->removeWritable(stream); @@ -503,7 +503,7 @@ void QuicStreamManager::updateWritableStreams(QuicStreamState& stream) { void QuicStreamManager::updatePeekableStreams(QuicStreamState& stream) { auto itr = peekableStreams_.find(stream.id); - if (!stream.hasPeekableData() || stream.streamReadError.hasValue()) { + if (!stream.hasPeekableData() || stream.streamReadError.has_value()) { if (itr != peekableStreams_.end()) { VLOG(10) << __func__ << " remove stream=" << stream.id << " " << stream.conn; diff --git a/quic/state/StreamData.h b/quic/state/StreamData.h index d76c672cd..910721a8d 100644 --- a/quic/state/StreamData.h +++ b/quic/state/StreamData.h @@ -222,7 +222,8 @@ struct QuicStreamState : public QuicStreamLike { // If the stream is still writable. bool writable() const { - return sendState == StreamSendState::Open_E && !finalWriteOffset.hasValue(); + return sendState == StreamSendState::Open_E && + !finalWriteOffset.has_value(); } bool shouldSendFlowControl() const { diff --git a/quic/state/stream/test/StreamStateMachineTest.cpp b/quic/state/stream/test/StreamStateMachineTest.cpp index 61d96d3e0..af61e2ec5 100644 --- a/quic/state/stream/test/StreamStateMachineTest.cpp +++ b/quic/state/stream/test/StreamStateMachineTest.cpp @@ -28,7 +28,7 @@ void verifyStreamReset( const QuicStreamState& stream, uint64_t readOffsetExpected) { EXPECT_TRUE(stream.readBuffer.empty()); - EXPECT_TRUE(stream.finalReadOffset.hasValue()); + EXPECT_TRUE(stream.finalReadOffset.has_value()); EXPECT_EQ(readOffsetExpected, stream.finalReadOffset.value()); } diff --git a/quic/state/test/AckHandlersTest.cpp b/quic/state/test/AckHandlersTest.cpp index 4774f99e8..c7ec5f4de 100644 --- a/quic/state/test/AckHandlersTest.cpp +++ b/quic/state/test/AckHandlersTest.cpp @@ -757,8 +757,8 @@ TEST_P(AckHandlersTest, AckNotOutstandingButLoss) { .WillOnce(Invoke( [&](folly::Optional ackEvent, folly::Optional lossEvent) { - EXPECT_FALSE(ackEvent->largestAckedPacket.hasValue()); - EXPECT_TRUE(lossEvent->largestLostPacketNum.hasValue()); + EXPECT_FALSE(ackEvent->largestAckedPacket.has_value()); + EXPECT_TRUE(lossEvent->largestLostPacketNum.has_value()); })); // But packet 1 has been outstanding for longer than delayUntilLost: diff --git a/quic/state/test/QPRFunctionsTest.cpp b/quic/state/test/QPRFunctionsTest.cpp index 04dbf9f3c..afd689e18 100644 --- a/quic/state/test/QPRFunctionsTest.cpp +++ b/quic/state/test/QPRFunctionsTest.cpp @@ -80,13 +80,13 @@ TEST_F(QPRFunctionsTest, AdvanceMinimumRetransmittableOffset) { stream->currentWriteOffset = 0; auto result = advanceMinimumRetransmittableOffset(stream, 4); EXPECT_EQ(stream->currentWriteOffset, 4); - EXPECT_TRUE(result.hasValue()); + EXPECT_TRUE(result.has_value()); EXPECT_EQ(stream->minimumRetransmittableOffset, 4); // case1. minimumRetransmittableOffset to set is too small stream->minimumRetransmittableOffset = 10; result = advanceMinimumRetransmittableOffset(stream, 1); - EXPECT_FALSE(result.hasValue()); + EXPECT_FALSE(result.has_value()); EXPECT_EQ(stream->minimumRetransmittableOffset, 10); auto buf = folly::IOBuf::copyBuffer("aaaaaaaaaa"); @@ -94,7 +94,7 @@ TEST_F(QPRFunctionsTest, AdvanceMinimumRetransmittableOffset) { stream->currentWriteOffset = 150; stream->retransmissionBuffer.emplace(140, StreamBuffer(buf->clone(), 140)); result = advanceMinimumRetransmittableOffset(stream, 139); - EXPECT_TRUE(result.hasValue()); + EXPECT_TRUE(result.has_value()); EXPECT_EQ(*result, 139); EXPECT_EQ(stream->minimumRetransmittableOffset, 139); EXPECT_EQ(stream->conn.pendingEvents.frames.size(), 1); @@ -103,7 +103,7 @@ TEST_F(QPRFunctionsTest, AdvanceMinimumRetransmittableOffset) { stream->minimumRetransmittableOffset = 139; stream->retransmissionBuffer.emplace(140, StreamBuffer(buf->clone(), 140)); result = advanceMinimumRetransmittableOffset(stream, 150); - EXPECT_TRUE(result.hasValue()); + EXPECT_TRUE(result.has_value()); EXPECT_EQ(*result, 150); EXPECT_EQ(stream->conn.pendingEvents.frames.size(), 1); { @@ -122,7 +122,7 @@ TEST_F(QPRFunctionsTest, AdvanceMinimumRetransmittableOffset) { stream->conn.pendingEvents.frames.emplace_back( ExpiredStreamDataFrame(stream->id, 160)); result = advanceMinimumRetransmittableOffset(stream, 200); - EXPECT_TRUE(result.hasValue()); + EXPECT_TRUE(result.has_value()); EXPECT_EQ(*result, 200); EXPECT_EQ(stream->conn.pendingEvents.frames.size(), 1); { @@ -214,7 +214,7 @@ TEST_F(QPRFunctionsTest, AdvanceCurrentReceiveOffset) { stream->currentReceiveOffset = 10; auto result = advanceCurrentReceiveOffset(stream, 1); EXPECT_EQ(stream->currentReceiveOffset, 10); - EXPECT_FALSE(result.hasValue()); + EXPECT_FALSE(result.has_value()); // case2. MinStreamDataFrame is put on the wire stream->currentReadOffset = 10; @@ -228,7 +228,7 @@ TEST_F(QPRFunctionsTest, AdvanceCurrentReceiveOffset) { EXPECT_EQ(minStreamDataFrame->minimumStreamOffset, 100); } } - EXPECT_TRUE(result.hasValue()); + EXPECT_TRUE(result.has_value()); EXPECT_EQ(*result, 100); // case3. update existing pending event @@ -246,7 +246,7 @@ TEST_F(QPRFunctionsTest, AdvanceCurrentReceiveOffset) { EXPECT_EQ(minStreamDataFrame->minimumStreamOffset, 150); } } - EXPECT_TRUE(result.hasValue()); + EXPECT_TRUE(result.has_value()); EXPECT_EQ(*result, 150); // case4. where offset was adjusted @@ -262,7 +262,7 @@ TEST_F(QPRFunctionsTest, AdvanceCurrentReceiveOffset) { EXPECT_EQ(minStreamDataFrame->minimumStreamOffset, 120); } } - EXPECT_TRUE(result.hasValue()); + EXPECT_TRUE(result.has_value()); EXPECT_EQ(*result, 120); } diff --git a/quic/state/test/QuicStateFunctionsTest.cpp b/quic/state/test/QuicStateFunctionsTest.cpp index 7dfaa498c..243bd16f2 100644 --- a/quic/state/test/QuicStateFunctionsTest.cpp +++ b/quic/state/test/QuicStateFunctionsTest.cpp @@ -619,7 +619,7 @@ TEST_P(QuicStateFunctionsTest, HasNotReceivedNewPacketsSinceLastClose) { TEST_F(QuicStateFunctionsTest, EarliestLossTimer) { QuicConnectionStateBase conn(QuicNodeType::Server); - EXPECT_FALSE(earliestLossTimer(conn).first.hasValue()); + EXPECT_FALSE(earliestLossTimer(conn).first.has_value()); auto currentTime = Clock::now(); // Before handshake completed