use the new quic-go stream deadline

Support for stream deadlines was added in
https://github.com/lucas-clemente/quic-go/pull/579.

conn.go

@@ -46,28 +46,19 @@ func newQuicConn(sess quic.Session, t tpt.Transport) (*quicConn, error) {
 		raddr:     raddr,
 		transport: t,
 	}
-
 	go c.watchClosed()
 
 	return c, nil
 }
 
 func (c *quicConn) AcceptStream() (smux.Stream, error) {
-	str, err := c.sess.AcceptStream()
-	if err != nil {
-		return nil, err
-	}
-	return &quicStream{Stream: str}, nil
+	return c.sess.AcceptStream()
 }
 
 // OpenStream opens a new stream
 // It blocks until a new stream can be opened (when limited by the QUIC maximum stream limit)
 func (c *quicConn) OpenStream() (smux.Stream, error) {
-	str, err := c.sess.OpenStreamSync()
-	if err != nil {
-		return nil, err
-	}
-	return &quicStream{Stream: str}, nil
+	return c.sess.OpenStreamSync()
 }
 
 func (c *quicConn) Serve(handler smux.StreamHandler) {

conn_test.go

@@ -3,6 +3,7 @@ package libp2pquic
 import (
 	"errors"
 	"net"
+	"time"
 
 	smux "github.com/jbenet/go-stream-muxer"
 	quic "github.com/lucas-clemente/quic-go"
@@ -21,6 +22,9 @@ func (s *mockStream) Reset(error)                 { return }
 func (s *mockStream) Read([]byte) (int, error)         { return 0, nil }
 func (s *mockStream) Write([]byte) (int, error)        { return 0, nil }
 func (s *mockStream) StreamID() protocol.StreamID      { return s.id }
+func (s *mockStream) SetReadDeadline(time.Time) error  { panic("not implemented") }
+func (s *mockStream) SetWriteDeadline(time.Time) error { panic("not implemented") }
+func (s *mockStream) SetDeadline(time.Time) error      { panic("not implemented") }
 
 var _ quic.Stream = &mockStream{}
 
@@ -97,7 +101,7 @@ var _ = Describe("Conn", func() {
 			sess.streamToOpen = s
 			str, err := conn.OpenStream()
 			Expect(err).ToNot(HaveOccurred())
-			Expect(str.(*quicStream).Stream).To(Equal(s))
+			Expect(str).To(Equal(s))
 		})
 
 		It("errors when it can't open a stream", func() {
@@ -114,7 +118,7 @@ var _ = Describe("Conn", func() {
 			sess.streamToAccept = s
 			str, err := conn.AcceptStream()
 			Expect(err).ToNot(HaveOccurred())
-			Expect(str.(*quicStream).Stream).To(Equal(s))
+			Expect(str).To(Equal(s))
 		})
 
 		It("errors when it can't open a stream", func() {
@@ -150,7 +154,7 @@ var _ = Describe("Conn", func() {
 				returned = true
 			}()
 			Eventually(func() bool { return handlerCalled }).Should(BeTrue())
-			Expect(handlerCalledWith.(*quicStream).Stream).To(Equal(str))
+			Expect(handlerCalledWith).To(Equal(str))
 			// make the go-routine return
 			sess.streamAcceptErr = errors.New("stop test")
 		})

stream.go

-package libp2pquic
-
-import (
-	"time"
-
-	smux "github.com/jbenet/go-stream-muxer"
-	quic "github.com/lucas-clemente/quic-go"
-)
-
-// The quicStream is a very thin wrapper for a quic.Stream, adding some methods
-// required to fulfill the smux.Stream interface
-// TODO: this can be removed once the quic.Stream supports deadlines (quic-go#514)
-type quicStream struct {
-	quic.Stream
-}
-
-var _ smux.Stream = &quicStream{}
-
-func (s *quicStream) SetDeadline(time.Time) error {
-	return nil
-}
-
-func (s *quicStream) SetReadDeadline(time.Time) error {
-	return nil
-}
-
-func (s *quicStream) SetWriteDeadline(time.Time) error {
-	return nil
-}