R=r
CC=golang-dev
https://golang.org/cl/4272052

Avoids 3 mallocs in a round trip encoding/decoding a struct.

R=rsc, rsc1
CC=golang-dev
https://golang.org/cl/4278052

R=golang-dev, adg
CC=golang-dev
https://golang.org/cl/4290049

R=adg
CC=golang-dev
https://golang.org/cl/4275054

R=adg
CC=golang-dev
https://golang.org/cl/4274059

If braces don't have position information for a composite
literal, don't assume alignment of key:value pairs under
the (wrong) assumption that there may be multiple lines.

R=rsc
CC=golang-dev
https://golang.org/cl/4297043

Add malloc counts for encode and decode.

R=rsc
CC=golang-dev
https://golang.org/cl/4290048

R=r
CC=golang-dev
https://golang.org/cl/4273060

R=rsc, dsymonds
CC=golang-dev
https://golang.org/cl/4290047

On my mac:
mallocs per rpc round trip: 144
rpc.BenchmarkEndToEnd	   10000	    228244 ns/op

Room for improvement.

R=rsc
CC=golang-dev
https://golang.org/cl/4274058

This makes it possible to build Windows binaries on non-Windows OSes.

R=golang-dev, rsc1, rsc
CC=golang-dev
https://golang.org/cl/4271046

The Windows code is untested.

R=rsc, gri, brainman, rsc1
CC=golang-dev
https://golang.org/cl/4253052

R=bradfitzgo, dsymonds, r, gri, adg
CC=golang-dev
https://golang.org/cl/4282044

R=ken2
CC=golang-dev
https://golang.org/cl/4287047

R=golang-dev, gri
CC=golang-dev
https://golang.org/cl/4274052

Swapping the goroutines lets them reuse the
communication completion on v instead of
needing a second channel (done).

R=gri
CC=golang-dev
https://golang.org/cl/4287045

Also change labelled examples to use gofmt formatting.

R=gri, r, jnml
CC=golang-dev
https://golang.org/cl/4287046

This matches the real ResponseWriter behavior.

R=rsc
CC=golang-dev
https://golang.org/cl/4291048

R=agl, agl1
CC=golang-dev
https://golang.org/cl/4297041

This reduces the number of writes by 2 (1 client, 1 server) on each round trip.
A simple test shows 24% higher throughput.

R=rsc
CC=golang-dev
https://golang.org/cl/4279057

R=golang-dev, r, dsymonds, rsc1
CC=golang-dev
https://golang.org/cl/4277046

R=ken2
CC=golang-dev
https://golang.org/cl/4279053

This change records more metadata about what
influenced the creation of the object file.
Specifically, if a package imports, say, "fmt" but does not
need to describe any fmt types in its own export data,
that package's object file did not mention the dependency
on "fmt" before.  Now it does.

Listing the import is purely informational.
It has no effect on which files are opened or consulted
when importing a package.

Import lines are marked indirect when they are needed
to explain the API but were not imported directly.
For example http imports crypto/tls and exports
a struct with a field of type tls.ConnectionState,
which contains an x509.Certificate.  Since http does
not import x509 but needs to explain the x509.Certificate
type in its export data, the import of x509 is marked
as indirect.  These import lines were always present;
marking them with the indirect comment makes clear
which were imported directly and which are incidental.

R=ken2
CC=golang-dev
https://golang.org/cl/4295048

R=golang-dev, dfc, rsc1, rsc
CC=golang-dev
https://golang.org/cl/4274048

Fixes #1555.

R=rsc, bradfitzgo
CC=golang-dev
https://golang.org/cl/4284047

R=rsc, dsymonds
CC=golang-dev
https://golang.org/cl/4278044

Also don't serialize empty headers.

R=dsymonds, rsc
CC=golang-dev
https://golang.org/cl/4275045

R=iant, dho
CC=golang-dev
https://golang.org/cl/4286044

R=rsc
CC=golang-dev
https://golang.org/cl/4275043

The loop always makes an extra system call.  It only makes a
difference if more than 100 goroutines started waiting for
something to happen on a network file descriptor since the
last time the pipe was drained, which is unlikely since we
will be woken up the first time a goroutine starts waiting.
If we don't drain the pipe this time, we'll be woken up again
right away and can drain again.

R=rsc
CC=golang-dev
https://golang.org/cl/4275042

Add a benchmark.
BenchmarkEndToEndPipe gives 14.3microseconds/op before,
13.1microseconds/op after, or about 76e3 round trips per second
through the kernel.
With a bytes buffer, and therefore no system calls for I/O, the
numbers go to 7.3microseconds/op, or about 137e3 round trips
per second.

R=rsc
CC=golang-dev
https://golang.org/cl/4279045

- removed uses of global variables
- minor cleanups

R=r
CC=golang-dev
https://golang.org/cl/4277044

R=rsc
CC=golang-dev
https://golang.org/cl/4278043

R=r, rsc1
CC=golang-dev
https://golang.org/cl/4291042

R=golang-dev, iant, r
CC=golang-dev
https://golang.org/cl/4239079

R=r, dsymonds
CC=golang-dev
https://golang.org/cl/4273045

R=golang-dev, rog, bradfitzwork, r
CC=golang-dev
https://golang.org/cl/4243072

R=ken2, ken3
CC=golang-dev
https://golang.org/cl/4259064

R=gri, r, r2
CC=golang-dev
https://golang.org/cl/4249065

Transport.Do -> RoundTripper.RoundTrip

This makes way for a subsequent CL to export the
currently private RoundTripper implementation
as struct Transport.

R=rsc, r
CC=golang-dev
https://golang.org/cl/4286043