Update godeps

vendor/google.golang.org/api/gensupport/media.go

@@ -5,7 +5,6 @@
 package gensupport
 
 import (
-	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -18,12 +17,12 @@ import (
 
 const sniffBuffSize = 512
 
-func NewContentSniffer(r io.Reader) *ContentSniffer {
-	return &ContentSniffer{r: r}
+func newContentSniffer(r io.Reader) *contentSniffer {
+	return &contentSniffer{r: r}
 }
 
-// ContentSniffer wraps a Reader, and reports the content type determined by sniffing up to 512 bytes from the Reader.
-type ContentSniffer struct {
+// contentSniffer wraps a Reader, and reports the content type determined by sniffing up to 512 bytes from the Reader.
+type contentSniffer struct {
 	r     io.Reader
 	start []byte // buffer for the sniffed bytes.
 	err   error  // set to any error encountered while reading bytes to be sniffed.
@@ -32,133 +31,169 @@ type ContentSniffer struct {
 	sniffed bool   // set to true on first sniff.
 }
 
-func (sct *ContentSniffer) Read(p []byte) (n int, err error) {
+func (cs *contentSniffer) Read(p []byte) (n int, err error) {
 	// Ensure that the content type is sniffed before any data is consumed from Reader.
-	_, _ = sct.ContentType()
+	_, _ = cs.ContentType()
 
-	if len(sct.start) > 0 {
-		n := copy(p, sct.start)
-		sct.start = sct.start[n:]
+	if len(cs.start) > 0 {
+		n := copy(p, cs.start)
+		cs.start = cs.start[n:]
 		return n, nil
 	}
 
 	// We may have read some bytes into start while sniffing, even if the read ended in an error.
 	// We should first return those bytes, then the error.
-	if sct.err != nil {
-		return 0, sct.err
+	if cs.err != nil {
+		return 0, cs.err
 	}
 
 	// Now we have handled all bytes that were buffered while sniffing.  Now just delegate to the underlying reader.
-	return sct.r.Read(p)
+	return cs.r.Read(p)
 }
 
 // ContentType returns the sniffed content type, and whether the content type was succesfully sniffed.
-func (sct *ContentSniffer) ContentType() (string, bool) {
-	if sct.sniffed {
-		return sct.ctype, sct.ctype != ""
+func (cs *contentSniffer) ContentType() (string, bool) {
+	if cs.sniffed {
+		return cs.ctype, cs.ctype != ""
 	}
-	sct.sniffed = true
+	cs.sniffed = true
 	// If ReadAll hits EOF, it returns err==nil.
-	sct.start, sct.err = ioutil.ReadAll(io.LimitReader(sct.r, sniffBuffSize))
+	cs.start, cs.err = ioutil.ReadAll(io.LimitReader(cs.r, sniffBuffSize))
 
 	// Don't try to detect the content type based on possibly incomplete data.
-	if sct.err != nil {
+	if cs.err != nil {
 		return "", false
 	}
 
-	sct.ctype = http.DetectContentType(sct.start)
-	return sct.ctype, true
+	cs.ctype = http.DetectContentType(cs.start)
+	return cs.ctype, true
 }
 
-// IncludeMedia combines an existing HTTP body with media content to create a multipart/related HTTP body.
-//
-// bodyp is an in/out parameter.  It should initially point to the
-// reader of the application/json (or whatever) payload to send in the
-// API request.  It's updated to point to the multipart body reader.
-//
-// ctypep is an in/out parameter.  It should initially point to the
-// content type of the bodyp, usually "application/json".  It's updated
-// to the "multipart/related" content type, with random boundary.
-//
-// The return value is a function that can be used to close the bodyp Reader with an error.
-func IncludeMedia(media io.Reader, bodyp *io.Reader, ctypep *string) func() {
-	var mediaType string
-	media, mediaType = getMediaType(media)
+// DetermineContentType determines the content type of the supplied reader.
+// If the content type is already known, it can be specified via ctype.
+// Otherwise, the content of media will be sniffed to determine the content type.
+// If media implements googleapi.ContentTyper (deprecated), this will be used
+// instead of sniffing the content.
+// After calling DetectContentType the caller must not perform further reads on
+// media, but rather read from the Reader that is returned.
+func DetermineContentType(media io.Reader, ctype string) (io.Reader, string) {
+	// Note: callers could avoid calling DetectContentType if ctype != "",
+	// but doing the check inside this function reduces the amount of
+	// generated code.
+	if ctype != "" {
+		return media, ctype
+	}
 
-	body, bodyType := *bodyp, *ctypep
-
-	pr, pw := io.Pipe()
-	mpw := multipart.NewWriter(pw)
-	*bodyp = pr
-	*ctypep = "multipart/related; boundary=" + mpw.Boundary()
-	go func() {
-		w, err := mpw.CreatePart(typeHeader(bodyType))
-		if err != nil {
-			mpw.Close()
-			pw.CloseWithError(fmt.Errorf("googleapi: body CreatePart failed: %v", err))
-			return
-		}
-		_, err = io.Copy(w, body)
-		if err != nil {
-			mpw.Close()
-			pw.CloseWithError(fmt.Errorf("googleapi: body Copy failed: %v", err))
-			return
-		}
-
-		w, err = mpw.CreatePart(typeHeader(mediaType))
-		if err != nil {
-			mpw.Close()
-			pw.CloseWithError(fmt.Errorf("googleapi: media CreatePart failed: %v", err))
-			return
-		}
-		_, err = io.Copy(w, media)
-		if err != nil {
-			mpw.Close()
-			pw.CloseWithError(fmt.Errorf("googleapi: media Copy failed: %v", err))
-			return
-		}
-		mpw.Close()
-		pw.Close()
-	}()
-	return func() { pw.CloseWithError(errAborted) }
-}
-
-var errAborted = errors.New("googleapi: upload aborted")
-
-func getMediaType(media io.Reader) (io.Reader, string) {
+	// For backwards compatability, allow clients to set content
+	// type by providing a ContentTyper for media.
 	if typer, ok := media.(googleapi.ContentTyper); ok {
 		return media, typer.ContentType()
 	}
 
-	sniffer := NewContentSniffer(media)
-	typ, ok := sniffer.ContentType()
-	if !ok {
-		// TODO(mcgreevy): Remove this default.  It maintains the semantics of the existing code,
-		// but should not be relied on.
-		typ = "application/octet-stream"
+	sniffer := newContentSniffer(media)
+	if ctype, ok := sniffer.ContentType(); ok {
+		return sniffer, ctype
 	}
-	return sniffer, typ
+	// If content type could not be sniffed, reads from sniffer will eventually fail with an error.
+	return sniffer, ""
 }
 
-// DetectMediaType detects and returns the content type of the provided media.
-// If the type can not be determined, "application/octet-stream" is returned.
-func DetectMediaType(media io.ReaderAt) string {
-	if typer, ok := media.(googleapi.ContentTyper); ok {
-		return typer.ContentType()
-	}
+type typeReader struct {
+	io.Reader
+	typ string
+}
 
-	typ := "application/octet-stream"
-	buf := make([]byte, 1024)
-	n, err := media.ReadAt(buf, 0)
-	buf = buf[:n]
-	if err == nil || err == io.EOF {
-		typ = http.DetectContentType(buf)
+// multipartReader combines the contents of multiple readers to creat a multipart/related HTTP body.
+// Close must be called if reads from the multipartReader are abandoned before reaching EOF.
+type multipartReader struct {
+	pr       *io.PipeReader
+	pipeOpen bool
+	ctype    string
+}
+
+func newMultipartReader(parts []typeReader) *multipartReader {
+	mp := &multipartReader{pipeOpen: true}
+	var pw *io.PipeWriter
+	mp.pr, pw = io.Pipe()
+	mpw := multipart.NewWriter(pw)
+	mp.ctype = "multipart/related; boundary=" + mpw.Boundary()
+	go func() {
+		for _, part := range parts {
+			w, err := mpw.CreatePart(typeHeader(part.typ))
+			if err != nil {
+				mpw.Close()
+				pw.CloseWithError(fmt.Errorf("googleapi: CreatePart failed: %v", err))
+				return
+			}
+			_, err = io.Copy(w, part.Reader)
+			if err != nil {
+				mpw.Close()
+				pw.CloseWithError(fmt.Errorf("googleapi: Copy failed: %v", err))
+				return
+			}
+		}
+
+		mpw.Close()
+		pw.Close()
+	}()
+	return mp
+}
+
+func (mp *multipartReader) Read(data []byte) (n int, err error) {
+	return mp.pr.Read(data)
+}
+
+func (mp *multipartReader) Close() error {
+	if !mp.pipeOpen {
+		return nil
 	}
-	return typ
+	mp.pipeOpen = false
+	return mp.pr.Close()
+}
+
+// CombineBodyMedia combines a json body with media content to create a multipart/related HTTP body.
+// It returns a ReadCloser containing the combined body, and the overall "multipart/related" content type, with random boundary.
+//
+// The caller must call Close on the returned ReadCloser if reads are abandoned before reaching EOF.
+func CombineBodyMedia(body io.Reader, bodyContentType string, media io.Reader, mediaContentType string) (io.ReadCloser, string) {
+	mp := newMultipartReader([]typeReader{
+		{body, bodyContentType},
+		{media, mediaContentType},
+	})
+	return mp, mp.ctype
 }
 
 func typeHeader(contentType string) textproto.MIMEHeader {
 	h := make(textproto.MIMEHeader)
-	h.Set("Content-Type", contentType)
+	if contentType != "" {
+		h.Set("Content-Type", contentType)
+	}
 	return h
 }
+
+// PrepareUpload determines whether the data in the supplied reader should be
+// uploaded in a single request, or in sequential chunks.
+// chunkSize is the size of the chunk that media should be split into.
+// If chunkSize is non-zero and the contents of media do not fit in a single
+// chunk (or there is an error reading media), then media will be returned as a
+// MediaBuffer.  Otherwise, media will be returned as a Reader.
+//
+// After PrepareUpload has been called, media should no longer be used: the
+// media content should be accessed via one of the return values.
+func PrepareUpload(media io.Reader, chunkSize int) (io.Reader, *MediaBuffer) {
+	if chunkSize == 0 { // do not chunk
+		return media, nil
+	}
+
+	mb := NewMediaBuffer(media, chunkSize)
+	rdr, _, _, err := mb.Chunk()
+
+	if err == io.EOF { // we can upload this in a single request
+		return rdr, nil
+	}
+	// err might be a non-EOF error. If it is, the next call to mb.Chunk will
+	// return the same error. Returning a MediaBuffer ensures that this error
+	// will be handled at some point.
+
+	return nil, mb
+}