remove unused context in Swarm.dialWorkerLoop

dial_sync.go

@@ -9,7 +9,7 @@ import (
 )
 
 // DialWorerFunc is used by DialSync to spawn a new dial worker
-type dialWorkerFunc func(context.Context, peer.ID, <-chan dialRequest) error
+type dialWorkerFunc func(peer.ID, <-chan dialRequest) error
 
 // newDialSync constructs a new DialSync
 func newDialSync(worker dialWorkerFunc) *DialSync {
@@ -94,8 +94,7 @@ func (ds *DialSync) getActiveDial(p peer.ID) (*activeDial, error) {
 			ds:     ds,
 		}
 
-		err := ds.dialWorker(adctx, p, actd.reqch)
-		if err != nil {
+		if err := ds.dialWorker(p, actd.reqch); err != nil {
 			cancel()
 			return nil, err
 		}

dial_sync_test.go

@@ -14,7 +14,7 @@ func getMockDialFunc() (dialWorkerFunc, func(), context.Context, <-chan struct{}
 	dfcalls := make(chan struct{}, 512) // buffer it large enough that we won't care
 	dialctx, cancel := context.WithCancel(context.Background())
 	ch := make(chan struct{})
-	f := func(ctx context.Context, p peer.ID, reqch <-chan dialRequest) error {
+	f := func(p peer.ID, reqch <-chan dialRequest) error {
 		dfcalls <- struct{}{}
 		go func() {
 			defer cancel()
@@ -24,16 +24,7 @@ func getMockDialFunc() (dialWorkerFunc, func(), context.Context, <-chan struct{}
 					if !ok {
 						return
 					}
-
-					select {
-					case <-ch:
-						req.resch <- dialResponse{conn: new(Conn)}
-					case <-ctx.Done():
-						req.resch <- dialResponse{err: ctx.Err()}
-						return
-					}
-				case <-ctx.Done():
-					return
+					req.resch <- dialResponse{conn: new(Conn)}
 				}
 			}
 		}()
@@ -187,25 +178,20 @@ func TestDialSyncAllCancel(t *testing.T) {
 
 func TestFailFirst(t *testing.T) {
 	var count int
-	f := func(ctx context.Context, p peer.ID, reqch <-chan dialRequest) error {
+	f := func(p peer.ID, reqch <-chan dialRequest) error {
 		go func() {
 			for {
-				select {
-				case req, ok := <-reqch:
-					if !ok {
-						return
-					}
-
-					if count > 0 {
-						req.resch <- dialResponse{conn: new(Conn)}
-					} else {
-						req.resch <- dialResponse{err: fmt.Errorf("gophers ate the modem")}
-					}
-					count++
-
-				case <-ctx.Done():
+				req, ok := <-reqch
+				if !ok {
 					return
 				}
+
+				if count > 0 {
+					req.resch <- dialResponse{conn: new(Conn)}
+				} else {
+					req.resch <- dialResponse{err: fmt.Errorf("gophers ate the modem")}
+				}
+				count++
 			}
 		}()
 		return nil
@@ -234,19 +220,14 @@ func TestFailFirst(t *testing.T) {
 }
 
 func TestStressActiveDial(t *testing.T) {
-	ds := newDialSync(func(ctx context.Context, p peer.ID, reqch <-chan dialRequest) error {
+	ds := newDialSync(func(p peer.ID, reqch <-chan dialRequest) error {
 		go func() {
 			for {
-				select {
-				case req, ok := <-reqch:
-					if !ok {
-						return
-					}
-
-					req.resch <- dialResponse{}
-				case <-ctx.Done():
+				req, ok := <-reqch
+				if !ok {
 					return
 				}
+				req.resch <- dialResponse{}
 			}
 		}()
 		return nil

swarm_dial.go

@@ -295,16 +295,16 @@ type dialResponse struct {
 }
 
 // startDialWorker starts an active dial goroutine that synchronizes and executes concurrent dials
-func (s *Swarm) startDialWorker(ctx context.Context, p peer.ID, reqch <-chan dialRequest) error {
+func (s *Swarm) startDialWorker(p peer.ID, reqch <-chan dialRequest) error {
 	if p == s.local {
 		return ErrDialToSelf
 	}
 
-	go s.dialWorkerLoop(ctx, p, reqch)
+	go s.dialWorkerLoop(p, reqch)
 	return nil
 }
 
-func (s *Swarm) dialWorkerLoop(ctx context.Context, p peer.ID, reqch <-chan dialRequest) {
+func (s *Swarm) dialWorkerLoop(p peer.ID, reqch <-chan dialRequest) {
 	defer s.limiter.clearAllPeerDials(p)
 
 	type pendRequest struct {