code review 69260044: net/http: add optional Server.ConnState callback

src/pkg/net/http/serve_test.go

 // Copyright 2010 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.
 
 // End-to-end serving tests
 
 package http_test
 
 import (
         "bufio"
@@ skipping 2226 matching lines @@
         res := ExportAppendTime(b[:0], t1)
         t2, err := ParseTime(string(res))
         if err != nil {
                 t.Fatalf("Error parsing time: %s", err)
         }
         if !t1.Equal(t2) {
                 t.Fatalf("Times differ; expected: %v, got %v (%s)", t1, t2, string(res))
         }
 }
 
-func TestConnectionState(t *testing.T) {
+func TestServerConnState(t *testing.T) {
         defer afterTest(t)
         handler := map[string]func(w ResponseWriter, r *Request){
                 "/": func(w ResponseWriter, r *Request) {
                         fmt.Fprintf(w, "Hello.")
                 },
                 "/close": func(w ResponseWriter, r *Request) {
                         w.Header().Set("Connection", "close")
                         fmt.Fprintf(w, "Hello.")
                 },
                 "/hijack": func(w ResponseWriter, r *Request) {
                         c, _, _ := w.(Hijacker).Hijack()
                         c.Write([]byte("HTTP/1.0 200 OK\r\nConnection: close\r\n\r\nHello."))
                         c.Close()
                 },
         }
         ts := httptest.NewUnstartedServer(HandlerFunc(func(w ResponseWriter, r *Request) {
                 handler[r.URL.Path](w, r)
         }))
         defer ts.Close()
 
         type connIDAndState struct {
                 connID int
                 state  ConnState
         }
         var mu sync.Mutex // guard stateLog and connID
         var stateLog []connIDAndState
         var connID = map[net.Conn]int{}
 
-        ts.Config.ClientConnState = func(c net.Conn, state ConnState) {
+        ts.Config.ConnState = func(c net.Conn, state ConnState) {
                 if c == nil {
                         t.Error("nil conn seen in state %s", state)
                         return
                 }
                 mu.Lock()
                 defer mu.Unlock()
                 id, ok := connID[c]
                 if !ok {
                         id = len(connID) + 1
                         connID[c] = id
                 }
                 stateLog = append(stateLog, connIDAndState{id, state})
         }
         ts.Start()
 
         mustGet(t, ts.URL+"/")
         mustGet(t, ts.URL+"/close")
 
         mustGet(t, ts.URL+"/")
         mustGet(t, ts.URL+"/", "Connection", "close")
 
         mustGet(t, ts.URL+"/hijack")
 
         want := []connIDAndState{
                 {1, StateNew},
-                {1, StateReading},
+                {1, StateActive},
                 {1, StateIdle},
-                {1, StateReading},
+                {1, StateActive},
                 {1, StateClosed},
 
                 {2, StateNew},
-                {2, StateReading},
+                {2, StateActive},
                 {2, StateIdle},
-                {2, StateReading},
+                {2, StateActive},
                 {2, StateClosed},
 
                 {3, StateNew},
-                {3, StateReading},
+                {3, StateActive},
                 {3, StateHijacked},
         }
         logString := func(l []connIDAndState) string {
                 var b bytes.Buffer
                 for _, cs := range l {
                         fmt.Fprintf(&b, "[%d %s] ", cs.connID, cs.state)
                 }
                 return b.String()
         }
 
@@ skipping 342 matching lines @@
                 closec: make(chan bool, 1),
         }
         ln := &oneConnListener{conn: conn}
         for i := 0; i < b.N; i++ {
                 conn.Reader = bytes.NewReader(req)
                 ln.conn = conn
                 Serve(ln, h)
                 <-conn.closec
         }
 }