diff --git a/ackhandler/interfaces.go b/ackhandler/interfaces.go
index 91f678567..05bbb1131 100644
--- a/ackhandler/interfaces.go
+++ b/ackhandler/interfaces.go
@@ -13,8 +13,8 @@ type SentPacketHandler interface {
 	DequeuePacketForRetransmission() (packet *Packet)
 }
 
-// IncomingPacketAckHandler handles ACKs needed to send for incoming packets
-type IncomingPacketAckHandler interface {
+// ReceivedPacketHandler handles ACKs needed to send for incoming packets
+type ReceivedPacketHandler interface {
 	ReceivedPacket(packetNumber protocol.PacketNumber, entropyBit bool) error
 	ReceivedStopWaiting(*frames.StopWaitingFrame) error
 
diff --git a/ackhandler/incoming_packet_ack_handler.go b/ackhandler/received_packet_handler.go
similarity index 74%
rename from ackhandler/incoming_packet_ack_handler.go
rename to ackhandler/received_packet_handler.go
index e66c73bc7..afe039756 100644
--- a/ackhandler/incoming_packet_ack_handler.go
+++ b/ackhandler/received_packet_handler.go
@@ -7,24 +7,23 @@ import (
 	"github.com/lucas-clemente/quic-go/protocol"
 )
 
-var ErrDuplicatePacket = errors.New("Duplicate Packet")
+var ErrDuplicatePacket = errors.New("ReceivedPacketHandler: Duplicate Packet")
 
-// The AckHandler handles ACKs
-type incomingPacketAckHandler struct {
+type receivedPacketHandler struct {
 	highestInOrderObserved        protocol.PacketNumber
 	highestInOrderObservedEntropy EntropyAccumulator
 	largestObserved               protocol.PacketNumber
 	packetHistory                 map[protocol.PacketNumber]bool // the bool is the EntropyBit of the packet
 }
 
-// NewIncomingPacketAckHandler creates a new outgoingPacketAckHandler
-func NewIncomingPacketAckHandler() IncomingPacketAckHandler {
-	return &incomingPacketAckHandler{
+// NewReceivedPacketHandler creates a new receivedPacketHandler
+func NewReceivedPacketHandler() ReceivedPacketHandler {
+	return &receivedPacketHandler{
 		packetHistory: make(map[protocol.PacketNumber]bool),
 	}
 }
 
-func (h *incomingPacketAckHandler) ReceivedPacket(packetNumber protocol.PacketNumber, entropyBit bool) error {
+func (h *receivedPacketHandler) ReceivedPacket(packetNumber protocol.PacketNumber, entropyBit bool) error {
 	if packetNumber == 0 {
 		return errors.New("Invalid packet number")
 	}
@@ -45,7 +44,7 @@ func (h *incomingPacketAckHandler) ReceivedPacket(packetNumber protocol.PacketNu
 	return nil
 }
 
-func (h *incomingPacketAckHandler) ReceivedStopWaiting(f *frames.StopWaitingFrame) error {
+func (h *receivedPacketHandler) ReceivedStopWaiting(f *frames.StopWaitingFrame) error {
 	// Ignore if STOP_WAITING is unneeded
 	if h.highestInOrderObserved >= f.LeastUnacked {
 		return nil
@@ -58,7 +57,7 @@ func (h *incomingPacketAckHandler) ReceivedStopWaiting(f *frames.StopWaitingFram
 }
 
 // getNackRanges gets all the NACK ranges
-func (h *incomingPacketAckHandler) getNackRanges() ([]frames.NackRange, EntropyAccumulator) {
+func (h *receivedPacketHandler) getNackRanges() ([]frames.NackRange, EntropyAccumulator) {
 	// ToDo: use a better data structure here
 	var ranges []frames.NackRange
 	inRange := false
@@ -84,7 +83,7 @@ func (h *incomingPacketAckHandler) getNackRanges() ([]frames.NackRange, EntropyA
 	return ranges, entropy
 }
 
-func (h *incomingPacketAckHandler) DequeueAckFrame() *frames.AckFrame {
+func (h *receivedPacketHandler) DequeueAckFrame() *frames.AckFrame {
 	nackRanges, entropy := h.getNackRanges()
 	return &frames.AckFrame{
 		LargestObserved: h.largestObserved,
diff --git a/ackhandler/incoming_packet_ack_handler_test.go b/ackhandler/received_packet_handler_test.go
similarity index 97%
rename from ackhandler/incoming_packet_ack_handler_test.go
rename to ackhandler/received_packet_handler_test.go
index 7020472bf..7939cb7fa 100644
--- a/ackhandler/incoming_packet_ack_handler_test.go
+++ b/ackhandler/received_packet_handler_test.go
@@ -8,14 +8,14 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("incomingPacketAckHandler", func() {
+var _ = Describe("receivedPacketHandler", func() {
 	var (
-		handler         *incomingPacketAckHandler
+		handler         *receivedPacketHandler
 		expectedEntropy EntropyAccumulator
 	)
 
 	BeforeEach(func() {
-		handler = NewIncomingPacketAckHandler().(*incomingPacketAckHandler)
+		handler = NewReceivedPacketHandler().(*receivedPacketHandler)
 		expectedEntropy = EntropyAccumulator(0)
 	})
 
diff --git a/session.go b/session.go
index a095e9b09..944a5c5c1 100644
--- a/session.go
+++ b/session.go
@@ -34,8 +34,8 @@ type Session struct {
 	streams      map[protocol.StreamID]*stream
 	streamsMutex sync.RWMutex
 
-	sentPacketHandler  ackhandler.SentPacketHandler
-	incomingAckHandler ackhandler.IncomingPacketAckHandler
+	sentPacketHandler     ackhandler.SentPacketHandler
+	receivedPacketHandler ackhandler.ReceivedPacketHandler
 
 	unpacker *packetUnpacker
 	packer   *packetPacker
@@ -46,12 +46,12 @@ type Session struct {
 // NewSession makes a new session
 func NewSession(conn *net.UDPConn, v protocol.VersionNumber, connectionID protocol.ConnectionID, sCfg *handshake.ServerConfig, streamCallback StreamCallback) PacketHandler {
 	session := &Session{
-		connection:         conn,
-		streamCallback:     streamCallback,
-		streams:            make(map[protocol.StreamID]*stream),
-		sentPacketHandler:  ackhandler.NewSentPacketHandler(),
-		incomingAckHandler: ackhandler.NewIncomingPacketAckHandler(),
-		receivedPackets:    make(chan receivedPacket),
+		connection:            conn,
+		streamCallback:        streamCallback,
+		streams:               make(map[protocol.StreamID]*stream),
+		sentPacketHandler:     ackhandler.NewSentPacketHandler(),
+		receivedPacketHandler: ackhandler.NewReceivedPacketHandler(),
+		receivedPackets:       make(chan receivedPacket),
 	}
 
 	cryptoStream, _ := session.NewStream(1)
@@ -95,8 +95,8 @@ func (s *Session) handlePacket(addr *net.UDPAddr, publicHeader *PublicHeader, r
 		return err
 	}
 
-	s.incomingAckHandler.ReceivedPacket(publicHeader.PacketNumber, packet.entropyBit)
-	s.QueueFrame(s.incomingAckHandler.DequeueAckFrame())
+	s.receivedPacketHandler.ReceivedPacket(publicHeader.PacketNumber, packet.entropyBit)
+	s.QueueFrame(s.receivedPacketHandler.DequeueAckFrame())
 
 	for _, ff := range packet.frames {
 		var err error
@@ -109,7 +109,7 @@ func (s *Session) handlePacket(addr *net.UDPAddr, publicHeader *PublicHeader, r
 		case *frames.ConnectionCloseFrame:
 			fmt.Printf("%#v\n", frame)
 		case *frames.StopWaitingFrame:
-			err = s.incomingAckHandler.ReceivedStopWaiting(frame)
+			err = s.receivedPacketHandler.ReceivedStopWaiting(frame)
 		case *frames.RstStreamFrame:
 			fmt.Printf("%#v\n", frame)
 		case *frames.WindowUpdateFrame: