refactor connection tests to remove ReceivedPacketHandler mock (#5468)

diff --git a/connection_test.go b/connection_test.go
index 08e280ac276f25686caee5b8a13c4bc2f90f096c..4e6f3e024dffe2f994dbf13952d9f20db6a8455f 100644 (file)
--- a/connection_test.go
+++ b/connection_test.go
@@ -548,14 +548,12 @@ func TestConnectionClientDrop0RTT(t *testing.T) {
 
 func TestConnectionUnpacking(t *testing.T) {
        mockCtrl := gomock.NewController(t)
-       rph := mockackhandler.NewMockReceivedPacketHandler(mockCtrl)
        unpacker := NewMockUnpacker(mockCtrl)
        var eventRecorder events.Recorder
        tc := newServerTestConnection(t,
                mockCtrl,
                nil,
                false,
-               connectionOptReceivedPacketHandler(rph),
                connectionOptUnpacker(unpacker),
                connectionOptTracer(&eventRecorder),
        )
@@ -582,10 +580,6 @@ func TestConnectionUnpacking(t *testing.T) {
                hdr:             &unpackedHdr,
                data:            []byte{0}, // one PADDING frame
        }, nil)
-       gomock.InOrder(
-               rph.EXPECT().IsPotentiallyDuplicate(protocol.PacketNumber(0x1337), protocol.EncryptionInitial),
-               rph.EXPECT().ReceivedPacket(protocol.PacketNumber(0x1337), protocol.ECNCE, protocol.EncryptionInitial, rcvTime, false),
-       )
 
        wasProcessed, err := tc.conn.handleOnePacket(packet, 42)
        require.NoError(t, err)
@@ -611,7 +605,6 @@ func TestConnectionUnpacking(t *testing.T) {
 
        // receive a duplicate of this packet
        packet = getLongHeaderPacket(t, tc.remoteAddr, hdr, nil)
-       rph.EXPECT().IsPotentiallyDuplicate(protocol.PacketNumber(0x1337), protocol.EncryptionInitial).Return(true)
        unpacker.EXPECT().UnpackLongHeader(gomock.Any(), gomock.Any()).Return(&unpackedPacket{
                encryptionLevel: protocol.EncryptionInitial,
                hdr:             &unpackedHdr,
@@ -642,10 +635,6 @@ func TestConnectionUnpacking(t *testing.T) {
        packet = getShortHeaderPacket(t, tc.remoteAddr, tc.srcConnID, 0x37, nil)
        packet.ecn = protocol.ECT1
        packet.rcvTime = rcvTime
-       gomock.InOrder(
-               rph.EXPECT().IsPotentiallyDuplicate(protocol.PacketNumber(0x1337), protocol.Encryption1RTT),
-               rph.EXPECT().ReceivedPacket(protocol.PacketNumber(0x1337), protocol.ECT1, protocol.Encryption1RTT, rcvTime, false),
-       )
        unpacker.EXPECT().UnpackShortHeader(gomock.Any(), gomock.Any()).Return(
                protocol.PacketNumber(0x1337), protocol.PacketNumberLen2, protocol.KeyPhaseZero, []byte{0} /* PADDING */, nil,
        )
@@ -672,14 +661,12 @@ func TestConnectionUnpacking(t *testing.T) {
 
 func TestConnectionUnpackCoalescedPacket(t *testing.T) {
        mockCtrl := gomock.NewController(t)
-       rph := mockackhandler.NewMockReceivedPacketHandler(mockCtrl)
        unpacker := NewMockUnpacker(mockCtrl)
        var eventRecorder events.Recorder
        tc := newServerTestConnection(t,
                mockCtrl,
                nil,
                false,
-               connectionOptReceivedPacketHandler(rph),
                connectionOptUnpacker(unpacker),
                connectionOptTracer(&eventRecorder),
        )
@@ -740,13 +727,6 @@ func TestConnectionUnpackCoalescedPacket(t *testing.T) {
                hdr:             &unpackedHdr2,
                data:            []byte{1}, // one PING frame
        }, nil)
-       gomock.InOrder(
-               rph.EXPECT().IsPotentiallyDuplicate(protocol.PacketNumber(1337), protocol.EncryptionInitial),
-               rph.EXPECT().ReceivedPacket(protocol.PacketNumber(1337), protocol.ECT1, protocol.EncryptionInitial, rcvTime, false),
-               rph.EXPECT().IsPotentiallyDuplicate(protocol.PacketNumber(1338), protocol.EncryptionHandshake),
-               rph.EXPECT().ReceivedPacket(protocol.PacketNumber(1338), protocol.ECT1, protocol.EncryptionHandshake, rcvTime, true),
-       )
-       rph.EXPECT().DropPackets(protocol.EncryptionInitial)
        wasProcessed, err := tc.conn.handleOnePacket(packet, 42)
        require.NoError(t, err)
        require.True(t, wasProcessed)
@@ -2128,8 +2108,8 @@ func testConnectionKeepAlive(t *testing.T, enable, expectKeepAlive bool) {
 func TestConnectionACKTimer(t *testing.T) {
        synctest.Test(t, func(t *testing.T) {
                mockCtrl := gomock.NewController(t)
-               rph := mockackhandler.NewMockReceivedPacketHandler(mockCtrl)
                sph := mockackhandler.NewMockSentPacketHandler(mockCtrl)
+               rph := ackhandler.NewReceivedPacketHandler(utils.DefaultLogger)
                tc := newServerTestConnection(t,
                        mockCtrl,
                        &Config{MaxIdleTimeout: time.Second},
@@ -2144,17 +2124,31 @@ func TestConnectionACKTimer(t *testing.T) {
                sph.EXPECT().SendMode(gomock.Any()).Return(ackhandler.SendAny).AnyTimes()
                sph.EXPECT().SentPacket(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
                sph.EXPECT().ECNMode(gomock.Any()).AnyTimes()
-               rph.EXPECT().GetAlarmTimeout().Return(monotime.Now().Add(time.Hour))
                tc.sendConn.EXPECT().Write(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
 
+               // Set initial alarm timeout far in the future
+               _ = rph.ReceivedPacket(1, protocol.ECNNon, protocol.Encryption1RTT, monotime.Now().Add(time.Hour), true)
+
                var times []monotime.Time
                done := make(chan struct{}, 5)
                var calls []any
-               for i := range 2 {
+
+               for range 2 {
                        calls = append(calls, tc.packer.EXPECT().AppendPacket(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
                                func(buf *packetBuffer, _ protocol.ByteCount, _ monotime.Time, _ protocol.Version) (shortHeaderPacket, error) {
                                        buf.Data = append(buf.Data, []byte("foobar")...)
                                        times = append(times, monotime.Now())
+                                       if len(times) == 1 {
+                                               // After first packet is sent, set alarm timeout for the next iteration
+                                               // Get the ACK frame to reset state, then receive a new packet to set alarm
+                                               _ = rph.GetAckFrame(protocol.Encryption1RTT, monotime.Now(), false)
+                                               alarmRcvTime := monotime.Now().Add(alarmTimeout - protocol.MaxAckDelay)
+                                               _ = rph.ReceivedPacket(2, protocol.ECNNon, protocol.Encryption1RTT, alarmRcvTime, true)
+                                       } else {
+                                               // After second packet is sent, set alarm timeout far in the future
+                                               _ = rph.GetAckFrame(protocol.Encryption1RTT, monotime.Now(), false)
+                                               _ = rph.ReceivedPacket(3, protocol.ECNNon, protocol.Encryption1RTT, monotime.Now().Add(time.Hour), true)
+                                       }
                                        return shortHeaderPacket{Frames: []ackhandler.Frame{{Frame: &wire.PingFrame{}}}, Length: 6}, nil
                                },
                        ))
@@ -2164,11 +2158,6 @@ func TestConnectionACKTimer(t *testing.T) {
                                        return shortHeaderPacket{}, errNothingToPack
                                },
                        ))
-                       if i == 0 {
-                               calls = append(calls, rph.EXPECT().GetAlarmTimeout().Return(monotime.Now().Add(alarmTimeout)))
-                       } else {
-                               calls = append(calls, rph.EXPECT().GetAlarmTimeout().Return(monotime.Now().Add(time.Hour)))
-                       }
                }
                gomock.InOrder(calls...)
                errChan := make(chan error, 1)

diff --git a/internal/mocks/ackhandler/received_packet_handler.go b/internal/mocks/ackhandler/received_packet_handler.go
deleted file mode 100644 (file)
index f8d6d77..0000000
--- a/internal/mocks/ackhandler/received_packet_handler.go
+++ /dev/null
@@ -1,267 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/quic-go/quic-go/internal/ackhandler (interfaces: ReceivedPacketHandler)
-//
-// Generated by this command:
-//
-//     mockgen -typed -build_flags=-tags=gomock -package mockackhandler -destination ackhandler/received_packet_handler.go github.com/quic-go/quic-go/internal/ackhandler ReceivedPacketHandler
-//
-
-// Package mockackhandler is a generated GoMock package.
-package mockackhandler
-
-import (
-       reflect "reflect"
-
-       monotime "github.com/quic-go/quic-go/internal/monotime"
-       protocol "github.com/quic-go/quic-go/internal/protocol"
-       wire "github.com/quic-go/quic-go/internal/wire"
-       gomock "go.uber.org/mock/gomock"
-)
-
-// MockReceivedPacketHandler is a mock of ReceivedPacketHandler interface.
-type MockReceivedPacketHandler struct {
-       ctrl     *gomock.Controller
-       recorder *MockReceivedPacketHandlerMockRecorder
-       isgomock struct{}
-}
-
-// MockReceivedPacketHandlerMockRecorder is the mock recorder for MockReceivedPacketHandler.
-type MockReceivedPacketHandlerMockRecorder struct {
-       mock *MockReceivedPacketHandler
-}
-
-// NewMockReceivedPacketHandler creates a new mock instance.
-func NewMockReceivedPacketHandler(ctrl *gomock.Controller) *MockReceivedPacketHandler {
-       mock := &MockReceivedPacketHandler{ctrl: ctrl}
-       mock.recorder = &MockReceivedPacketHandlerMockRecorder{mock}
-       return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockReceivedPacketHandler) EXPECT() *MockReceivedPacketHandlerMockRecorder {
-       return m.recorder
-}
-
-// DropPackets mocks base method.
-func (m *MockReceivedPacketHandler) DropPackets(arg0 protocol.EncryptionLevel) {
-       m.ctrl.T.Helper()
-       m.ctrl.Call(m, "DropPackets", arg0)
-}
-
-// DropPackets indicates an expected call of DropPackets.
-func (mr *MockReceivedPacketHandlerMockRecorder) DropPackets(arg0 any) *MockReceivedPacketHandlerDropPacketsCall {
-       mr.mock.ctrl.T.Helper()
-       call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropPackets", reflect.TypeOf((*MockReceivedPacketHandler)(nil).DropPackets), arg0)
-       return &MockReceivedPacketHandlerDropPacketsCall{Call: call}
-}
-
-// MockReceivedPacketHandlerDropPacketsCall wrap *gomock.Call
-type MockReceivedPacketHandlerDropPacketsCall struct {
-       *gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockReceivedPacketHandlerDropPacketsCall) Return() *MockReceivedPacketHandlerDropPacketsCall {
-       c.Call = c.Call.Return()
-       return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockReceivedPacketHandlerDropPacketsCall) Do(f func(protocol.EncryptionLevel)) *MockReceivedPacketHandlerDropPacketsCall {
-       c.Call = c.Call.Do(f)
-       return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockReceivedPacketHandlerDropPacketsCall) DoAndReturn(f func(protocol.EncryptionLevel)) *MockReceivedPacketHandlerDropPacketsCall {
-       c.Call = c.Call.DoAndReturn(f)
-       return c
-}
-
-// GetAckFrame mocks base method.
-func (m *MockReceivedPacketHandler) GetAckFrame(arg0 protocol.EncryptionLevel, now monotime.Time, onlyIfQueued bool) *wire.AckFrame {
-       m.ctrl.T.Helper()
-       ret := m.ctrl.Call(m, "GetAckFrame", arg0, now, onlyIfQueued)
-       ret0, _ := ret[0].(*wire.AckFrame)
-       return ret0
-}
-
-// GetAckFrame indicates an expected call of GetAckFrame.
-func (mr *MockReceivedPacketHandlerMockRecorder) GetAckFrame(arg0, now, onlyIfQueued any) *MockReceivedPacketHandlerGetAckFrameCall {
-       mr.mock.ctrl.T.Helper()
-       call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAckFrame), arg0, now, onlyIfQueued)
-       return &MockReceivedPacketHandlerGetAckFrameCall{Call: call}
-}
-
-// MockReceivedPacketHandlerGetAckFrameCall wrap *gomock.Call
-type MockReceivedPacketHandlerGetAckFrameCall struct {
-       *gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockReceivedPacketHandlerGetAckFrameCall) Return(arg0 *wire.AckFrame) *MockReceivedPacketHandlerGetAckFrameCall {
-       c.Call = c.Call.Return(arg0)
-       return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockReceivedPacketHandlerGetAckFrameCall) Do(f func(protocol.EncryptionLevel, monotime.Time, bool) *wire.AckFrame) *MockReceivedPacketHandlerGetAckFrameCall {
-       c.Call = c.Call.Do(f)
-       return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockReceivedPacketHandlerGetAckFrameCall) DoAndReturn(f func(protocol.EncryptionLevel, monotime.Time, bool) *wire.AckFrame) *MockReceivedPacketHandlerGetAckFrameCall {
-       c.Call = c.Call.DoAndReturn(f)
-       return c
-}
-
-// GetAlarmTimeout mocks base method.
-func (m *MockReceivedPacketHandler) GetAlarmTimeout() monotime.Time {
-       m.ctrl.T.Helper()
-       ret := m.ctrl.Call(m, "GetAlarmTimeout")
-       ret0, _ := ret[0].(monotime.Time)
-       return ret0
-}
-
-// GetAlarmTimeout indicates an expected call of GetAlarmTimeout.
-func (mr *MockReceivedPacketHandlerMockRecorder) GetAlarmTimeout() *MockReceivedPacketHandlerGetAlarmTimeoutCall {
-       mr.mock.ctrl.T.Helper()
-       call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAlarmTimeout", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAlarmTimeout))
-       return &MockReceivedPacketHandlerGetAlarmTimeoutCall{Call: call}
-}
-
-// MockReceivedPacketHandlerGetAlarmTimeoutCall wrap *gomock.Call
-type MockReceivedPacketHandlerGetAlarmTimeoutCall struct {
-       *gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockReceivedPacketHandlerGetAlarmTimeoutCall) Return(arg0 monotime.Time) *MockReceivedPacketHandlerGetAlarmTimeoutCall {
-       c.Call = c.Call.Return(arg0)
-       return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockReceivedPacketHandlerGetAlarmTimeoutCall) Do(f func() monotime.Time) *MockReceivedPacketHandlerGetAlarmTimeoutCall {
-       c.Call = c.Call.Do(f)
-       return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockReceivedPacketHandlerGetAlarmTimeoutCall) DoAndReturn(f func() monotime.Time) *MockReceivedPacketHandlerGetAlarmTimeoutCall {
-       c.Call = c.Call.DoAndReturn(f)
-       return c
-}
-
-// IgnorePacketsBelow mocks base method.
-func (m *MockReceivedPacketHandler) IgnorePacketsBelow(arg0 protocol.PacketNumber) {
-       m.ctrl.T.Helper()
-       m.ctrl.Call(m, "IgnorePacketsBelow", arg0)
-}
-
-// IgnorePacketsBelow indicates an expected call of IgnorePacketsBelow.
-func (mr *MockReceivedPacketHandlerMockRecorder) IgnorePacketsBelow(arg0 any) *MockReceivedPacketHandlerIgnorePacketsBelowCall {
-       mr.mock.ctrl.T.Helper()
-       call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IgnorePacketsBelow", reflect.TypeOf((*MockReceivedPacketHandler)(nil).IgnorePacketsBelow), arg0)
-       return &MockReceivedPacketHandlerIgnorePacketsBelowCall{Call: call}
-}
-
-// MockReceivedPacketHandlerIgnorePacketsBelowCall wrap *gomock.Call
-type MockReceivedPacketHandlerIgnorePacketsBelowCall struct {
-       *gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockReceivedPacketHandlerIgnorePacketsBelowCall) Return() *MockReceivedPacketHandlerIgnorePacketsBelowCall {
-       c.Call = c.Call.Return()
-       return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockReceivedPacketHandlerIgnorePacketsBelowCall) Do(f func(protocol.PacketNumber)) *MockReceivedPacketHandlerIgnorePacketsBelowCall {
-       c.Call = c.Call.Do(f)
-       return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockReceivedPacketHandlerIgnorePacketsBelowCall) DoAndReturn(f func(protocol.PacketNumber)) *MockReceivedPacketHandlerIgnorePacketsBelowCall {
-       c.Call = c.Call.DoAndReturn(f)
-       return c
-}
-
-// IsPotentiallyDuplicate mocks base method.
-func (m *MockReceivedPacketHandler) IsPotentiallyDuplicate(arg0 protocol.PacketNumber, arg1 protocol.EncryptionLevel) bool {
-       m.ctrl.T.Helper()
-       ret := m.ctrl.Call(m, "IsPotentiallyDuplicate", arg0, arg1)
-       ret0, _ := ret[0].(bool)
-       return ret0
-}
-
-// IsPotentiallyDuplicate indicates an expected call of IsPotentiallyDuplicate.
-func (mr *MockReceivedPacketHandlerMockRecorder) IsPotentiallyDuplicate(arg0, arg1 any) *MockReceivedPacketHandlerIsPotentiallyDuplicateCall {
-       mr.mock.ctrl.T.Helper()
-       call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPotentiallyDuplicate", reflect.TypeOf((*MockReceivedPacketHandler)(nil).IsPotentiallyDuplicate), arg0, arg1)
-       return &MockReceivedPacketHandlerIsPotentiallyDuplicateCall{Call: call}
-}
-
-// MockReceivedPacketHandlerIsPotentiallyDuplicateCall wrap *gomock.Call
-type MockReceivedPacketHandlerIsPotentiallyDuplicateCall struct {
-       *gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockReceivedPacketHandlerIsPotentiallyDuplicateCall) Return(arg0 bool) *MockReceivedPacketHandlerIsPotentiallyDuplicateCall {
-       c.Call = c.Call.Return(arg0)
-       return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockReceivedPacketHandlerIsPotentiallyDuplicateCall) Do(f func(protocol.PacketNumber, protocol.EncryptionLevel) bool) *MockReceivedPacketHandlerIsPotentiallyDuplicateCall {
-       c.Call = c.Call.Do(f)
-       return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockReceivedPacketHandlerIsPotentiallyDuplicateCall) DoAndReturn(f func(protocol.PacketNumber, protocol.EncryptionLevel) bool) *MockReceivedPacketHandlerIsPotentiallyDuplicateCall {
-       c.Call = c.Call.DoAndReturn(f)
-       return c
-}
-
-// ReceivedPacket mocks base method.
-func (m *MockReceivedPacketHandler) ReceivedPacket(pn protocol.PacketNumber, ecn protocol.ECN, encLevel protocol.EncryptionLevel, rcvTime monotime.Time, ackEliciting bool) error {
-       m.ctrl.T.Helper()
-       ret := m.ctrl.Call(m, "ReceivedPacket", pn, ecn, encLevel, rcvTime, ackEliciting)
-       ret0, _ := ret[0].(error)
-       return ret0
-}
-
-// ReceivedPacket indicates an expected call of ReceivedPacket.
-func (mr *MockReceivedPacketHandlerMockRecorder) ReceivedPacket(pn, ecn, encLevel, rcvTime, ackEliciting any) *MockReceivedPacketHandlerReceivedPacketCall {
-       mr.mock.ctrl.T.Helper()
-       call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockReceivedPacketHandler)(nil).ReceivedPacket), pn, ecn, encLevel, rcvTime, ackEliciting)
-       return &MockReceivedPacketHandlerReceivedPacketCall{Call: call}
-}
-
-// MockReceivedPacketHandlerReceivedPacketCall wrap *gomock.Call
-type MockReceivedPacketHandlerReceivedPacketCall struct {
-       *gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockReceivedPacketHandlerReceivedPacketCall) Return(arg0 error) *MockReceivedPacketHandlerReceivedPacketCall {
-       c.Call = c.Call.Return(arg0)
-       return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockReceivedPacketHandlerReceivedPacketCall) Do(f func(protocol.PacketNumber, protocol.ECN, protocol.EncryptionLevel, monotime.Time, bool) error) *MockReceivedPacketHandlerReceivedPacketCall {
-       c.Call = c.Call.Do(f)
-       return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockReceivedPacketHandlerReceivedPacketCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ECN, protocol.EncryptionLevel, monotime.Time, bool) error) *MockReceivedPacketHandlerReceivedPacketCall {
-       c.Call = c.Call.DoAndReturn(f)
-       return c
-}

diff --git a/internal/mocks/mockgen.go b/internal/mocks/mockgen.go
index a67d936a752c326f001c11cfdf44850b739a0c5f..04c5bcc857aae66b9660c032510082371f163664 100644 (file)
--- a/internal/mocks/mockgen.go
+++ b/internal/mocks/mockgen.go
@@ -9,4 +9,3 @@ package mocks
 //go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package mocks -destination stream_flow_controller.go github.com/quic-go/quic-go/internal/flowcontrol StreamFlowController"
 //go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package mocks -destination congestion.go github.com/quic-go/quic-go/internal/congestion SendAlgorithmWithDebugInfos"
 //go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package mockackhandler -destination ackhandler/sent_packet_handler.go github.com/quic-go/quic-go/internal/ackhandler SentPacketHandler"
-//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package mockackhandler -destination ackhandler/received_packet_handler.go github.com/quic-go/quic-go/internal/ackhandler ReceivedPacketHandler"