Update to current Go library.

From-SVN: r171732

4 files changed, 42 insertions, 9 deletions

diff --git a/libgo/go/http/fs.go b/libgo/go/http/fs.go
index 4ad680c..8b5c477 100644
--- a/libgo/go/http/fs.go
+++ b/libgo/go/http/fs.go
@@ -154,7 +154,10 @@ func serveFile(w ResponseWriter, r *Request, name string, redirect bool) {
 	// handle Content-Range header.
 	// TODO(adg): handle multiple ranges
 	ranges, err := parseRange(r.Header.Get("Range"), size)
-	if err != nil || len(ranges) > 1 {
+	if err == nil && len(ranges) > 1 {
+		err = os.ErrorString("multiple ranges not supported")
+	}
+	if err != nil {
 		Error(w, err.String(), StatusRequestedRangeNotSatisfiable)
 		return
 	}
diff --git a/libgo/go/http/pprof/pprof.go b/libgo/go/http/pprof/pprof.go
index 0bac266..bc79e21 100644
--- a/libgo/go/http/pprof/pprof.go
+++ b/libgo/go/http/pprof/pprof.go
@@ -18,6 +18,10 @@
 //
 //	pprof http://localhost:6060/debug/pprof/heap
 //
+// Or to look at a 30-second CPU profile:
+//
+//	pprof http://localhost:6060/debug/pprof/profile
+//
 package pprof
 
 import (
@@ -29,10 +33,12 @@ import (
 	"runtime/pprof"
 	"strconv"
 	"strings"
+	"time"
 )
 
 func init() {
 	http.Handle("/debug/pprof/cmdline", http.HandlerFunc(Cmdline))
+	http.Handle("/debug/pprof/profile", http.HandlerFunc(Profile))
 	http.Handle("/debug/pprof/heap", http.HandlerFunc(Heap))
 	http.Handle("/debug/pprof/symbol", http.HandlerFunc(Symbol))
 }
@@ -41,22 +47,46 @@ func init() {
 // command line, with arguments separated by NUL bytes.
 // The package initialization registers it as /debug/pprof/cmdline.
 func Cmdline(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("content-type", "text/plain; charset=utf-8")
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
 	fmt.Fprintf(w, strings.Join(os.Args, "\x00"))
 }
 
 // Heap responds with the pprof-formatted heap profile.
 // The package initialization registers it as /debug/pprof/heap.
 func Heap(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("content-type", "text/plain; charset=utf-8")
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
 	pprof.WriteHeapProfile(w)
 }
 
+// Profile responds with the pprof-formatted cpu profile.
+// The package initialization registers it as /debug/pprof/profile.
+func Profile(w http.ResponseWriter, r *http.Request) {
+	sec, _ := strconv.Atoi64(r.FormValue("seconds"))
+	if sec == 0 {
+		sec = 30
+	}
+
+	// Set Content Type assuming StartCPUProfile will work,
+	// because if it does it starts writing.
+	w.Header().Set("Content-Type", "application/octet-stream")
+	if err := pprof.StartCPUProfile(w); err != nil {
+		// StartCPUProfile failed, so no writes yet.
+		// Can change header back to text content
+		// and send error code.
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		w.WriteHeader(http.StatusInternalServerError)
+		fmt.Fprintf(w, "Could not enable CPU profiling: %s\n", err)
+		return
+	}
+	time.Sleep(sec * 1e9)
+	pprof.StopCPUProfile()
+}
+
 // Symbol looks up the program counters listed in the request,
 // responding with a table mapping program counters to function names.
 // The package initialization registers it as /debug/pprof/symbol.
 func Symbol(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("content-type", "text/plain; charset=utf-8")
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
 
 	// We don't know how many symbols we have, but we
 	// do have symbol information.  Pprof only cares whether
diff --git a/libgo/go/http/serve_test.go b/libgo/go/http/serve_test.go
index 683de85..b0e26e5 100644
--- a/libgo/go/http/serve_test.go
+++ b/libgo/go/http/serve_test.go
@@ -175,7 +175,7 @@ func TestHostHandlers(t *testing.T) {
 	ts := httptest.NewServer(nil)
 	defer ts.Close()
 
-	conn, err := net.Dial("tcp", "", ts.Listener.Addr().String())
+	conn, err := net.Dial("tcp", ts.Listener.Addr().String())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -265,7 +265,7 @@ func TestServerTimeouts(t *testing.T) {
 
 	// Slow client that should timeout.
 	t1 := time.Nanoseconds()
-	conn, err := net.Dial("tcp", "", fmt.Sprintf("localhost:%d", addr.Port))
+	conn, err := net.Dial("tcp", fmt.Sprintf("localhost:%d", addr.Port))
 	if err != nil {
 		t.Fatalf("Dial: %v", err)
 	}
@@ -348,7 +348,7 @@ func TestIdentityResponse(t *testing.T) {
 	}
 	// Verify that the connection is closed when the declared Content-Length
 	// is larger than what the handler wrote.
-	conn, err := net.Dial("tcp", "", ts.Listener.Addr().String())
+	conn, err := net.Dial("tcp", ts.Listener.Addr().String())
 	if err != nil {
 		t.Fatalf("error dialing: %v", err)
 	}
@@ -377,7 +377,7 @@ func TestServeHTTP10Close(t *testing.T) {
 	}))
 	defer s.Close()
 
-	conn, err := net.Dial("tcp", "", s.Listener.Addr().String())
+	conn, err := net.Dial("tcp", s.Listener.Addr().String())
 	if err != nil {
 		t.Fatal("dial error:", err)
 	}
diff --git a/libgo/go/http/transport.go b/libgo/go/http/transport.go
index 8a73ead..ed7843b 100644
--- a/libgo/go/http/transport.go
+++ b/libgo/go/http/transport.go
@@ -195,7 +195,7 @@ func (t *Transport) getConn(cm *connectMethod) (*persistConn, os.Error) {
 		return pc, nil
 	}
 
-	conn, err := net.Dial("tcp", "", cm.addr())
+	conn, err := net.Dial("tcp", cm.addr())
 	if err != nil {
 		return nil, err
 	}