code review 4607052: os.Error API: don't export os.ErrorString, use os.NewEr...

src/pkg/http/client.go

 // Copyright 2009 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.
 
 // Primitive HTTP client. See RFC 2616.
 
 package http
 
 import (
         "encoding/base64"
         "fmt"
         "io"
         "os"
         "strings"
 )
 
 // A Client is an HTTP client. Its zero value (DefaultClient) is a usable client
 // that uses DefaultTransport.
+//
+// The Client's Transport typically has internal state (cached
+// TCP connections), so Clients should be reused instead of created as
+// needed. Clients are safe for concurrent use by multiple goroutines.
+//
 // Client is not yet very configurable.
 type Client struct {
         Transport RoundTripper // if nil, DefaultTransport is used
 
         // If CheckRedirect is not nil, the client calls it before
         // following an HTTP redirect. The arguments req and via
         // are the upcoming request and the requests made already,
         // oldest first. If CheckRedirect returns an error, the client
         // returns that error instead of issue the Request req.
         //
         // If CheckRedirect is nil, the Client uses its default policy,
         // which is to stop after 10 consecutive requests.
         CheckRedirect func(req *Request, via []*Request) os.Error
 }
 
 // DefaultClient is the default Client and is used by Get, Head, and Post.
 var DefaultClient = &Client{}
 
 // RoundTripper is an interface representing the ability to execute a
 // single HTTP transaction, obtaining the Response for a given Request.
+//
+// A RoundTripper must be safe for concurrent use by multiple
+// goroutines.
 type RoundTripper interface {
         // RoundTrip executes a single HTTP transaction, returning
         // the Response for the request req.  RoundTrip should not
         // attempt to interpret the response.  In particular,
         // RoundTrip must return err == nil if it obtained a response,
         // regardless of the response's HTTP status code.  A non-nil
         // err should be reserved for failure to obtain a response.
         // Similarly, RoundTrip should not attempt to handle
         // higher-level protocol details such as redirects,
         // authentication, or cookies.
@@ skipping 117 matching lines @@
                         req.Method = ireq.Method
                         req.Header = make(Header)
                         req.URL, err = base.ParseURL(url)
                         if err != nil {
                                 break
                         }
                         if len(via) > 0 {
                                 // Add the Referer header.
                                 lastReq := via[len(via)-1]
                                 if lastReq.URL.Scheme != "https" {
-                                        req.Referer = lastReq.URL.String()
+                                        req.Header.Set("Referer", lastReq.URL.String())
                                 }
 
                                 err = redirectChecker(req, via)
                                 if err != nil {
                                         break
                                 }
                         }
                 }
 
                 url = req.URL.String()
@@ skipping 86 matching lines @@
 //    302 (Found)
 //    303 (See Other)
 //    307 (Temporary Redirect)
 func (c *Client) Head(url string) (r *Response, err os.Error) {
         req, err := NewRequest("HEAD", url, nil)
         if err != nil {
                 return nil, err
         }
         return c.doFollowingRedirects(req)
 }