if pconn.alt != nil {
  // HTTP/2 path.
  t.setReqCanceler(req, nil) // not cancelable with CancelRequest
  resp, err = pconn.alt.RoundTrip(req)
} else {
  resp, err = pconn.roundTrip(treq)
  if err == nil && resp.isProtocolSwitch() {
    upgradeProto := resp.Header.Get("Upgrade")
    if upgradeFn, ok := t.upgradeNextProto[upgradeProto]; ok {
      t2 := upgradeFn(cm.targetAddr, pconn.conn)
      pconn.alt = t2
      resp, err = t2.completeUpgrade(req)
    }
  }
}

// You can edit this code!
// Click here and start typing.
package main

import (
	"bufio"
	"context"
	"fmt"
	"net"
	"net/http"
	"net/http/httputil"
	"time"

	"golang.org/x/net/http2"
	"golang.org/x/net/http2/h2c"
)

func main() {
	go runH2CServer()
	time.Sleep(1)
	doClient()

}

func runH2CServer() {
	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.ProtoMajor != 2 && r.Header.Get("Upgrade") != "h2c" {
			w.WriteHeader(http.StatusBadRequest)
			fmt.Fprint(w, "Expected h2c request")
			return
		}

		w.Write([]byte("hi"))
	})
	h2c := &http.Server{
		Addr:    ":3001",
		Handler: h2c.NewHandler(handler, &http2.Server{}),
	}
	fmt.Printf("Starting server, listening on port %s (h2c)\n", h2c.Addr)
	h2c.ListenAndServe()
}

func doClient() {
	dialer := &net.Dialer{}

	conn, err := dialer.DialContext(context.Background(), "tcp", "localhost:3001")
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	bw := bufio.NewWriter(conn)
	br := bufio.NewReader(conn)

	req, _ := http.NewRequest("GET", "http://localhost:3001", nil)
	req.Header.Set("Connection", "Upgrade, HTTP2-Settings")
	req.Header.Set("Upgrade", "h2c")
	req.Header.Set("HTTP2-Settings", "AAMAAABkAARAAAAAAAIAAAAA")

	if err := req.Write(bw); err != nil {
		panic(err)
	}
	if err := bw.Flush(); err != nil {
		panic(err)
	}

	resp, err := http.ReadResponse(br, req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	bytes, err := httputil.DumpResponse(resp, false)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Response:\n%v\n", string(bytes))

	transport := &http2.Transport{}
	h2cConn, err := transport.NewClientConn(conn)
	if err != nil {
		panic(err)
	}
	defer h2cConn.Close()

	req, _ = http.NewRequest("GET", "http://localhost:3001", nil)
	resp, err = h2cConn.RoundTrip(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	bytes, err = httputil.DumpResponse(resp, true)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Response:\n%v\n", string(bytes))
}