WIP(x/http/client): net/http/client

[spongehah]

• http.Get()
• In order to return the response without stopping the loop, Use channels to pass the response.
• [tmp] timeout
• header: Add textproto to process header and support custom header
• Add the post request
  • http.Post()
  • http.PostForm()
• redirect
• cookie-jar
• maxConnsPerHost
• http proxy
• 100-continue
• http.bodyEOFSignal and http.body struct
• one loop per transport
• retry
• gzip reader
• Trailer
• ConnPool
• Mutiple eventLoop

Implementation logic:

t.RoundTrip() {
    once.Do(func(){
       t.loop = libuv.LoopNew()
       t.async = &libuv.Async{}
       t.exec = hyper.NewExecutor()
       t.loop.Async(t.async, asyncCb)
       checker := &libuv.Check{}
       libuv.InitCheck(t.loop, checker)
       (*libuv.Handle)(c.Pointer(checker)).SetData(c.Pointer(t))
       checker.Start(readWriteLoop)
       go t.loop.Run(libuv.RUN_DEFAULT)
    })
    ...
    pc, err := t.getConn(req) {
       pc = &persistConn{
          t:             t,
          cacheKey:      cm.key(),
          closech:       make(chan struct{}, 1),
          writeLoopDone: make(chan struct{}, 1),
       }
       return pc, nil
    }
    ...
    resp, err = pc.roundTrip(req) {
       resc := make(chan responseAndError)
       handshakeTask := hyper.Handshake(hyperIo, opts)
       taskData := &taskData{
          taskId:     write,
          req:        req,
          pc:         pc,
          addedGzip:  requestedGzip,
          writeErrCh: writeErrCh,
          callerGone: gone,
          resc:       resc,
       }
       handshakeTask.SetUserdata(c.Pointer(taskData))
       pc.t.exec.Push(handshakeTask)
       // Wake up libuv. Loop
       pc.t.async.Send()
       select {
       case re := <-resc: // Waiting for pc.startLoop() to put response into resc
          if re.err != nil {
             return nil, re.err
          }
          return re.res, nil
       case <-pc.timeoutch:
          return nil, fmt.Errorf("request timeout\n")
       }
    }
    ...
    if err == nil {
       return resp, nil
    }
    
    // Retry
}
func readWriteLoop(checker *libuv.Check) {
    for {
       task := t.exec.poll()
       if task == nil {
          return
       }
       taskData := (*taskData)(task.Userdata())
       var taskId taskId
       if taskData != nil {
          taskId = taskData.taskId
       } else {
          taskId = notSet
       }
       switch taskId {
       case write:
          t.exec.push(writeTask)
       case read:
          readResponse()
          t.exec.push(bodyForEachTask)
          taskData.resc <- responseAndError{res: resp, err: err}
       case readDone:
          // respBody has been read completely
       case notset:
       }
    }
}