code review 71740043: net/http: minor fixes and optimization for Response.TLS

src/pkg/net/http/transport.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // HTTP client implementation. See RFC 2616.
 //
 // This is the low-level Transport implementation of RoundTripper.
 // The high-level interface is in client.go.
 
 package http
@@ skipping 565 matching lines @@
                 if err := <-errc; err != nil {
                         plainConn.Close()
                         return nil, err
                 }
                 if !cfg.InsecureSkipVerify {
                         if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
                                 plainConn.Close()
                                 return nil, err
                         }
                 }
+                cs := tlsConn.ConnectionState()
+                pconn.tlsState = &cs
                 pconn.conn = tlsConn
         }
 
         pconn.br = bufio.NewReader(pconn.conn)
         pconn.bw = bufio.NewWriter(pconn.conn)
         go pconn.readLoop()
         go pconn.writeLoop()
         return pconn, nil
 }
 
@@ skipping 115 matching lines @@
         // Only used by tests.
         return fmt.Sprintf("%s|%s|%s", k.proxy, k.scheme, k.addr)
 }
 
 // persistConn wraps a connection, usually a persistent one
 // (but may be used for non-keep-alive requests as well)
 type persistConn struct {
         t        *Transport
         cacheKey connectMethodKey
         conn     net.Conn
+        tlsState *tls.ConnectionState
         closed   bool                // whether conn has been closed
         br       *bufio.Reader       // from conn
         bw       *bufio.Writer       // to conn
         reqch    chan requestAndChan // written by roundTrip; read by readLoop
         writech  chan writeRequest   // written by roundTrip; read by writeLoop
         closech  chan struct{}       // broadcast close when readLoop (TCP connection) closes
         isProxy  bool
 
         lk                   sync.Mutex // guards following 3 fields
         numExpectedResponses int
@@ skipping 54 matching lines @@
                         if err == nil && resp.StatusCode == 100 {
                                 // Skip any 100-continue for now.
                                 // TODO(bradfitz): if rc.req had "Expect: 100-continue",
                                 // actually block the request body write and signal the
                                 // writeLoop now to begin sending it. (Issue 2184) For now we
                                 // eat it, since we're never expecting one.
                                 resp, err = ReadResponse(pc.br, rc.req)
                         }
                 }
 
-                if tlsConn, ok := pc.conn.(*tls.Conn); resp != nil && ok {
-                        resp.TLS = new(tls.ConnectionState)
-                        *resp.TLS = tlsConn.ConnectionState()
+                if resp != nil {
+                        resp.TLS = pc.tlsState
                 }
 
                 hasBody := resp != nil && rc.req.Method != "HEAD" && resp.ContentLength != 0
 
                 if err != nil {
                         pc.close()
                 } else {
                         if rc.addedGzip && hasBody && resp.Header.Get("Content-Encoding") == "gzip" {
                                 resp.Header.Del("Content-Encoding")
                                 resp.Header.Del("Content-Length")
@@ skipping 317 matching lines @@
 type readerAndCloser struct {
         io.Reader
         io.Closer
 }
 
 type tlsHandshakeTimeoutError struct{}
 
 func (tlsHandshakeTimeoutError) Timeout() bool   { return true }
 func (tlsHandshakeTimeoutError) Temporary() bool { return true }
 func (tlsHandshakeTimeoutError) Error() string   { return "net/http: TLS handshake timeout" }