diff --git a/frames/stream_frame.go b/frames/stream_frame.go
index b7be58f0..f0f5ada5 100644
--- a/frames/stream_frame.go
+++ b/frames/stream_frame.go
@@ -203,3 +203,8 @@ func (f *StreamFrame) MinLength() (protocol.ByteCount, error) {
 
 	return length + 1, nil
 }
+
+// DataLen gives the length of data in bytes
+func (f *StreamFrame) DataLen() protocol.ByteCount {
+	return protocol.ByteCount(len(f.Data))
+}
diff --git a/frames/stream_frame_test.go b/frames/stream_frame_test.go
index f365ac8b..921688b7 100644
--- a/frames/stream_frame_test.go
+++ b/frames/stream_frame_test.go
@@ -377,4 +377,13 @@ var _ = Describe("StreamFrame", func() {
 			Expect(f.getOffsetLength()).To(Equal(protocol.ByteCount(8)))
 		})
 	})
+
+	Context("DataLen", func() {
+		It("determines the length of the data", func() {
+			frame := StreamFrame{
+				Data: []byte("foobar"),
+			}
+			Expect(frame.DataLen()).To(Equal(protocol.ByteCount(6)))
+		})
+	})
 })
diff --git a/packet_packer.go b/packet_packer.go
index d164afed..b18610a7 100644
--- a/packet_packer.go
+++ b/packet_packer.go
@@ -212,9 +212,9 @@ func (p *packetPacker) composeNextPacket(stopWaitingFrame *frames.StopWaitingFra
 		frame.DataLenPresent = true // set the dataLen by default. Remove them later if applicable
 
 		frameMinLength, _ := frame.MinLength() // StreamFrame.MinLength *never* returns an error
-		payloadLength += frameMinLength - 1 + protocol.ByteCount(len(frame.Data))
+		payloadLength += frameMinLength - 1 + frame.DataLen()
 
-		blockedFrame := p.blockedManager.GetBlockedFrame(frame.StreamID, frame.Offset+protocol.ByteCount(len(frame.Data)))
+		blockedFrame := p.blockedManager.GetBlockedFrame(frame.StreamID, frame.Offset+frame.DataLen())
 		if blockedFrame != nil {
 			blockedLength, _ := blockedFrame.MinLength() // BlockedFrame.MinLength *never* returns an error
 			if payloadLength+blockedLength <= maxFrameSize {
diff --git a/session.go b/session.go
index 813ca2d9..be99bf83 100644
--- a/session.go
+++ b/session.go
@@ -242,7 +242,7 @@ func (s *Session) handlePacketImpl(remoteAddr interface{}, hdr *publicHeader, da
 		var err error
 		switch frame := ff.(type) {
 		case *frames.StreamFrame:
-			utils.Debugf("\t<- &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", frame.StreamID, frame.FinBit, frame.Offset, len(frame.Data), frame.Offset+protocol.ByteCount(len(frame.Data)))
+			utils.Debugf("\t<- &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", frame.StreamID, frame.FinBit, frame.Offset, frame.DataLen(), frame.Offset+frame.DataLen())
 			err = s.handleStreamFrame(frame)
 			// TODO: send RstStreamFrame
 		case *frames.AckFrame:
@@ -563,7 +563,7 @@ func (s *Session) logPacket(packet *packedPacket) {
 	utils.Debugf("-> Sending packet 0x%x (%d bytes)", packet.number, len(packet.raw))
 	for _, frame := range packet.frames {
 		if streamFrame, isStreamFrame := frame.(*frames.StreamFrame); isStreamFrame {
-			utils.Debugf("\t-> &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", streamFrame.StreamID, streamFrame.FinBit, streamFrame.Offset, len(streamFrame.Data), streamFrame.Offset+protocol.ByteCount(len(streamFrame.Data)))
+			utils.Debugf("\t-> &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", streamFrame.StreamID, streamFrame.FinBit, streamFrame.Offset, streamFrame.DataLen(), streamFrame.Offset+streamFrame.DataLen())
 		} else {
 			utils.Debugf("\t-> %#v", frame)
 		}
diff --git a/stream.go b/stream.go
index 29e008e4..4f9d4fed 100644
--- a/stream.go
+++ b/stream.go
@@ -99,7 +99,7 @@ func (s *stream) Read(p []byte) (int, error) {
 			}
 			if frame != nil {
 				// Pop and continue if the frame doesn't have any new data
-				if frame.Offset+protocol.ByteCount(len(frame.Data)) <= s.readOffset && !frame.FinBit {
+				if frame.Offset+frame.DataLen() <= s.readOffset && !frame.FinBit {
 					s.frameQueue.Pop()
 					frame = s.frameQueue.Head()
 					continue
@@ -123,7 +123,7 @@ func (s *stream) Read(p []byte) (int, error) {
 			return bytesRead, s.err
 		}
 
-		m := utils.Min(len(p)-bytesRead, len(frame.Data)-s.readPosInFrame)
+		m := utils.Min(len(p)-bytesRead, int(frame.DataLen())-s.readPosInFrame)
 		copy(p[bytesRead:], frame.Data[s.readPosInFrame:])
 
 		s.readPosInFrame += m
@@ -137,7 +137,7 @@ func (s *stream) Read(p []byte) (int, error) {
 
 		s.maybeTriggerWindowUpdate()
 
-		if s.readPosInFrame >= len(frame.Data) {
+		if s.readPosInFrame >= int(frame.DataLen()) {
 			fin := frame.FinBit
 			s.mutex.Lock()
 			s.frameQueue.Pop()
@@ -240,7 +240,7 @@ func (s *stream) Close() error {
 
 // AddStreamFrame adds a new stream frame
 func (s *stream) AddStreamFrame(frame *frames.StreamFrame) error {
-	maxOffset := frame.Offset + protocol.ByteCount(len(frame.Data))
+	maxOffset := frame.Offset + frame.DataLen()
 	increment := s.flowController.UpdateHighestReceived(maxOffset)
 	if s.contributesToConnectionFlowControl {
 		s.connectionFlowController.IncrementHighestReceived(increment)
diff --git a/stream_frame_queue.go b/stream_frame_queue.go
index e19da938..2f7f5882 100644
--- a/stream_frame_queue.go
+++ b/stream_frame_queue.go
@@ -46,7 +46,7 @@ func (q *streamFrameQueue) Push(frame *frames.StreamFrame, prio bool) {
 		}
 	}
 
-	q.byteLen += protocol.ByteCount(len(frame.Data))
+	q.byteLen += frame.DataLen()
 	q.len++
 }
 
@@ -99,7 +99,7 @@ func (q *streamFrameQueue) Pop(maxLength protocol.ByteCount) (*frames.StreamFram
 	splitFrame := q.maybeSplitOffFrame(frame, maxLength)
 
 	if splitFrame != nil { // StreamFrame was split
-		q.byteLen -= protocol.ByteCount(len(splitFrame.Data))
+		q.byteLen -= splitFrame.DataLen()
 		return splitFrame, nil
 	}
 
@@ -110,7 +110,7 @@ func (q *streamFrameQueue) Pop(maxLength protocol.ByteCount) (*frames.StreamFram
 		q.frameMap[streamID] = q.frameMap[streamID][1:]
 	}
 
-	q.byteLen -= protocol.ByteCount(len(frame.Data))
+	q.byteLen -= frame.DataLen()
 	q.len--
 	return frame, nil
 }
@@ -144,7 +144,7 @@ func (q *streamFrameQueue) getNextStream() (protocol.StreamID, error) {
 // has to be called from a function that has already acquired the mutex
 func (q *streamFrameQueue) maybeSplitOffFrame(frame *frames.StreamFrame, n protocol.ByteCount) *frames.StreamFrame {
 	minLength, _ := frame.MinLength() // StreamFrame.MinLength *never* errors
-	if n >= minLength-1+protocol.ByteCount(len(frame.Data)) {
+	if n >= minLength-1+frame.DataLen() {
 		return nil
 	}
 	n -= minLength - 1
diff --git a/stream_frame_queue_test.go b/stream_frame_queue_test.go
index 4af4be3a..33b728dc 100644
--- a/stream_frame_queue_test.go
+++ b/stream_frame_queue_test.go
@@ -76,15 +76,15 @@ var _ = Describe("streamFrameQueue", func() {
 			queue.Push(prioFrame1, true)
 			Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(2)))
 			queue.Push(frame2, false)
-			Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(len(prioFrame1.Data) + len(frame2.Data))))
+			Expect(queue.ByteLen()).To(Equal(prioFrame1.DataLen() + frame2.DataLen()))
 		})
 
 		It("returns the correct byte length when popping", func() {
 			queue.Push(prioFrame1, true)
 			queue.Push(frame1, false)
-			Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(len(prioFrame1.Data) + len(frame1.Data))))
+			Expect(queue.ByteLen()).To(Equal(prioFrame1.DataLen() + frame1.DataLen()))
 			queue.Pop(1000)
-			Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(len(frame1.Data))))
+			Expect(queue.ByteLen()).To(Equal(frame1.DataLen()))
 			queue.Pop(1000)
 			Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(0)))
 		})
@@ -117,7 +117,7 @@ var _ = Describe("streamFrameQueue", func() {
 		It("does not change the byte length when using getNextStream()", func() {
 			queue.Push(prioFrame1, true)
 			queue.Push(frame1, false)
-			length := protocol.ByteCount(len(prioFrame1.Data) + len(frame1.Data))
+			length := prioFrame1.DataLen() + frame1.DataLen()
 			Expect(queue.ByteLen()).To(Equal(length))
 			_, err := queue.getNextStream()
 			Expect(err).ToNot(HaveOccurred())
@@ -275,13 +275,13 @@ var _ = Describe("streamFrameQueue", func() {
 
 			It("splits a frame", func() {
 				queue.Push(frame1, false)
-				origlen := len(frame1.Data)
+				origlen := frame1.DataLen()
 				frame, err := queue.Pop(6)
 				Expect(err).ToNot(HaveOccurred())
 				minLength, _ := frame.MinLength()
-				Expect(int(minLength) - 1 + len(frame.Data)).To(Equal(6))
-				Expect(queue.frameMap[frame1.StreamID][0].Data).To(HaveLen(origlen - len(frame.Data)))
-				Expect(queue.frameMap[frame1.StreamID][0].Offset).To(Equal(protocol.ByteCount(len(frame.Data))))
+				Expect(minLength - 1 + frame.DataLen()).To(Equal(protocol.ByteCount(6)))
+				Expect(queue.frameMap[frame1.StreamID][0].Data).To(HaveLen(int(origlen - frame.DataLen())))
+				Expect(queue.frameMap[frame1.StreamID][0].Offset).To(Equal(frame.DataLen()))
 			})
 
 			It("only removes a frame from the queue after return all split parts", func() {
@@ -298,7 +298,7 @@ var _ = Describe("streamFrameQueue", func() {
 			})
 
 			It("gets the whole data of a frame, when it was split", func() {
-				length := len(frame1.Data)
+				length := frame1.DataLen()
 				origdata := make([]byte, length)
 				copy(origdata, frame1.Data)
 				queue.Push(frame1, false)
@@ -306,10 +306,10 @@ var _ = Describe("streamFrameQueue", func() {
 				Expect(err).ToNot(HaveOccurred())
 				nextframe, err := queue.Pop(1000)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(len(frame.Data) + len(nextframe.Data)).To(Equal(length))
+				Expect(frame.DataLen() + nextframe.DataLen()).To(Equal(length))
 				data := make([]byte, length)
 				copy(data, frame.Data)
-				copy(data[len(frame.Data):], nextframe.Data)
+				copy(data[int(frame.DataLen()):], nextframe.Data)
 				Expect(data).To(Equal(origdata))
 			})
 
@@ -320,7 +320,7 @@ var _ = Describe("streamFrameQueue", func() {
 				frame, err := queue.Pop(6)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(frame.StreamID).To(Equal(frame1.StreamID)) // make sure the right frame was popped
-				Expect(queue.ByteLen()).To(Equal(startByteLength - protocol.ByteCount(len(frame.Data))))
+				Expect(queue.ByteLen()).To(Equal(startByteLength - frame.DataLen()))
 			})
 
 			It("does not change the length of the queue when returning a split frame", func() {