code review 5399043: net/http: Added interface for a cookie jar.

src/pkg/net/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.
 
 // HTTP client. See RFC 2616.
 //·
 // This is the high-level Client interface.
 // The low-level implementation is in transport.go.
 
 package http
@@ skipping 20 matching lines @@
 
         // 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) error
+
+        // Jar specifies the cookie jar.·
+        // If Jar is nil, cookies are not sent in requests and ignored·
+        // in responses.
+        Jar CookieJar
 }
 
 // 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.
@@ skipping 122 matching lines @@
         redirectChecker := c.CheckRedirect
         if redirectChecker == nil {
                 redirectChecker = defaultCheckRedirect
         }
         var via []*Request
 
         if ireq.URL == nil {
                 return nil, errors.New("http: nil Request.URL")
         }
 
+        jar := c.Jar
+        if jar == nil {
+                jar = blackHoleJar{}
+        }
+
         req := ireq
         urlStr := "" // next relative or absolute URL to fetch (after first request)
         for redirect := 0; ; redirect++ {
                 if redirect != 0 {
                         req = new(Request)
                         req.Method = ireq.Method
                         req.Header = make(Header)
                         req.URL, err = base.Parse(urlStr)
                         if err != nil {
                                 break
                         }
                         if len(via) > 0 {
                                 // Add the Referer header.
                                 lastReq := via[len(via)-1]
                                 if lastReq.URL.Scheme != "https" {
                                         req.Header.Set("Referer", lastReq.URL.String())
                                 }
 
                                 err = redirectChecker(req, via)
                                 if err != nil {
                                         break
                                 }
                         }
+                        for _, cookie := range jar.Cookies(req.URL) {
+                                req.AddCookie(cookie)
+                        }
                 }
 
                 urlStr = req.URL.String()
                 if r, err = send(req, c.Transport); err != nil {
                         break
                 }
+                if c := r.Cookies(); len(c) > 0 {
+                        jar.SetCookies(req.URL, c)
+                }
+
                 if shouldRedirect(r.StatusCode) {
                         r.Body.Close()
                         if urlStr = r.Header.Get("Location"); urlStr == "" {
                                 err = errors.New(fmt.Sprintf("%d response missing Location header", r.StatusCode))
                                 break
                         }
                         base = req.URL
                         via = append(via, req)
                         continue
                 }
@@ skipping 73 matching lines @@
 //    302 (Found)
 //    303 (See Other)
 //    307 (Temporary Redirect)
 func (c *Client) Head(url string) (r *Response, err error) {
         req, err := NewRequest("HEAD", url, nil)
         if err != nil {
                 return nil, err
         }
         return c.doFollowingRedirects(req)
 }