move httpProxyDialer to newHTTPProxyDialerFunc()

client.go

@@ -255,23 +255,21 @@ func (d *Dialer) DialContext(ctx context.Context, urlStr string, requestHeader h
 			return nil, nil, err
 		}
 		if proxyURL != nil {
-			netDial, err = func(proxyURL *url.URL, forwardDial netDialerFunc) (netDialerFunc, error) {
+			forwardDial := newNetDialerFunc(proxyURL.Scheme, d.NetDial, d.NetDialContext, d.NetDialTLSContext)
-				if proxyURL.Scheme == "http" {
+			if proxyURL.Scheme == "http" || proxyURL.Scheme == "https" {
-					return (&httpProxyDialer{proxyURL: proxyURL, forwardDial: forwardDial}).DialContext, nil
+				netDial = newHTTPProxyDialerFunc(proxyURL, forwardDial)
-				}
+			} else {
 				dialer, err := proxy.FromURL(proxyURL, forwardDial)
 				if err != nil {
-					return nil, err
+					return nil, nil, err
 				}
 				if d, ok := dialer.(proxy.ContextDialer); ok {
-					return d.DialContext, nil
+					netDial = d.DialContext
+				} else {
+					netDial = func(ctx context.Context, net, addr string) (net.Conn, error) {
+						return dialer.Dial(net, addr)
+					}
 				}
-				return func(ctx context.Context, net, addr string) (net.Conn, error) {
-					return dialer.Dial(net, addr)
-				}, nil
-			}(proxyURL, netDial)
-			if err != nil {
-				return nil, nil, err
 			}
 		}
 	}

proxy.go

@@ -46,62 +46,59 @@ func (fn netDialerFunc) DialContext(ctx context.Context, network, addr string) (
 	return fn(ctx, network, addr)
 }
 
-type httpProxyDialer struct {
+func newHTTPProxyDialerFunc(proxyURL *url.URL, forwardDial netDialerFunc) netDialerFunc {
-	proxyURL    *url.URL
+	return func(ctx context.Context, network, addr string) (net.Conn, error) {
-	forwardDial netDialerFunc
+		hostPort, _ := hostPortNoPort(proxyURL)
-}
+		conn, err := forwardDial(ctx, network, hostPort)
-
+		if err != nil {
-func (hpd *httpProxyDialer) DialContext(ctx context.Context, network string, addr string) (net.Conn, error) {
+			return nil, err
-	hostPort, _ := hostPortNoPort(hpd.proxyURL)
-	conn, err := hpd.forwardDial(ctx, network, hostPort)
-	if err != nil {
-		return nil, err
-	}
-
-	connectHeader := make(http.Header)
-	if user := hpd.proxyURL.User; user != nil {
-		proxyUser := user.Username()
-		if proxyPassword, passwordSet := user.Password(); passwordSet {
-			credential := base64.StdEncoding.EncodeToString([]byte(proxyUser + ":" + proxyPassword))
-			connectHeader.Set("Proxy-Authorization", "Basic "+credential)
 		}
-	}
 
-	connectReq := &http.Request{
+		connectHeader := make(http.Header)
-		Method: http.MethodConnect,
+		if user := proxyURL.User; user != nil {
-		URL:    &url.URL{Opaque: addr},
+			proxyUser := user.Username()
-		Host:   addr,
+			if proxyPassword, passwordSet := user.Password(); passwordSet {
-		Header: connectHeader,
+				credential := base64.StdEncoding.EncodeToString([]byte(proxyUser + ":" + proxyPassword))
-	}
+				connectHeader.Set("Proxy-Authorization", "Basic "+credential)
+			}
+		}
 
-	if err := connectReq.Write(conn); err != nil {
+		connectReq := &http.Request{
-		conn.Close()
+			Method: http.MethodConnect,
-		return nil, err
+			URL:    &url.URL{Opaque: addr},
-	}
+			Host:   addr,
+			Header: connectHeader,
+		}
 
-	// Read response. It's OK to use and discard buffered reader here because
+		if err := connectReq.Write(conn); err != nil {
-	// the remote server does not speak until spoken to.
+			conn.Close()
-	br := bufio.NewReader(conn)
+			return nil, err
-	resp, err := http.ReadResponse(br, connectReq)
+		}
-	if err != nil {
-		conn.Close()
-		return nil, err
-	}
 
-	// Close the response body to silence false positives from linters. Reset
+		// Read response. It's OK to use and discard buffered reader here because
-	// the buffered reader first to ensure that Close() does not read from
+		// the remote server does not speak until spoken to.
-	// conn.
+		br := bufio.NewReader(conn)
-	// Note: Applications must call resp.Body.Close() on a response returned
+		resp, err := http.ReadResponse(br, connectReq)
-	// http.ReadResponse to inspect trailers or read another response from the
+		if err != nil {
-	// buffered reader. The call to resp.Body.Close() does not release
+			conn.Close()
-	// resources.
+			return nil, err
-	br.Reset(bytes.NewReader(nil))
+		}
-	_ = resp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
+		// Close the response body to silence false positives from linters. Reset
-		_ = conn.Close()
+		// the buffered reader first to ensure that Close() does not read from
-		f := strings.SplitN(resp.Status, " ", 2)
+		// conn.
-		return nil, errors.New(f[1])
+		// Note: Applications must call resp.Body.Close() on a response returned
+		// http.ReadResponse to inspect trailers or read another response from the
+		// buffered reader. The call to resp.Body.Close() does not release
+		// resources.
+		br.Reset(bytes.NewReader(nil))
+		_ = resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			_ = conn.Close()
+			f := strings.SplitN(resp.Status, " ", 2)
+			return nil, errors.New(f[1])
+		}
+		return conn, nil
 	}
-	return conn, nil
 }