fix interpretation of time.Time{} as a pacing deadline

The pacer returns the zero value of time.Time when a packet can be sent
immediately. The session uses the zero value to unset the pacing
deadline.

internal/congestion/pacer.go

@@ -57,6 +57,7 @@ func (p *pacer) maxBurstSize() protocol.ByteCount {
 }
 
 // TimeUntilSend returns when the next packet should be sent.
+// It returns the zero value of time.Time if a packet can be sent immediately.
 func (p *pacer) TimeUntilSend() time.Time {
 	if p.budgetAtLastSent >= maxDatagramSize {
 		return time.Time{}

session.go

@@ -211,9 +211,10 @@ type session struct {
 }
 
 var (
-	_ Session      = &session{}
+	_                       Session      = &session{}
-	_ EarlySession = &session{}
+	_                       EarlySession = &session{}
-	_ streamSender = &session{}
+	_                       streamSender = &session{}
+	deadlineSendImmediately              = time.Time{}.Add(42 * time.Millisecond) // any value > time.Time{} and before time.Now() is fine
 )
 
 var newSession = func(
@@ -1484,7 +1485,11 @@ func (s *session) sendPackets() error {
 			}
 		case ackhandler.SendAny:
 			if s.handshakeComplete && !s.sentPacketHandler.HasPacingBudget() {
-				s.pacingDeadline = s.sentPacketHandler.TimeUntilSend()
+				deadline := s.sentPacketHandler.TimeUntilSend()
+				if deadline.IsZero() {
+					deadline = deadlineSendImmediately
+				}
+				s.pacingDeadline = deadline
 				return nil
 			}
 			sent, err := s.sendPacket()

session_test.go

@@ -1379,7 +1379,25 @@ var _ = Describe("Session", func() {
 				sess.run()
 			}()
 			sess.scheduleSending()
-			time.Sleep(50 * time.Millisecond) // make sure that only 2 packes are sent
+			time.Sleep(50 * time.Millisecond) // make sure that only 2 packets are sent
+		})
+
+		It("sends multiple packets, when the pacer allows immediate sending", func() {
+			sph.EXPECT().SentPacket(gomock.Any())
+			sph.EXPECT().HasPacingBudget()
+			sph.EXPECT().HasPacingBudget().Return(true).AnyTimes()
+			sph.EXPECT().TimeUntilSend() // return the zero value of time.Time{}
+			sph.EXPECT().SendMode().Return(ackhandler.SendAny).Times(3)
+			packer.EXPECT().PackPacket().Return(getPacket(10), nil)
+			packer.EXPECT().PackPacket().Return(nil, nil)
+			mconn.EXPECT().Write(gomock.Any())
+			go func() {
+				defer GinkgoRecover()
+				cryptoSetup.EXPECT().RunHandshake().MaxTimes(1)
+				sess.run()
+			}()
+			sess.scheduleSending()
+			time.Sleep(50 * time.Millisecond) // make sure that only 1 packet is sent
 		})
 
 		// when becoming congestion limited, at some point the SendMode will change from SendAny to SendAck