http2/h2c: add h2c implementation (unencrypted HTTP/2)

Implements h2c by leveraging the existing http2.Server by implementing the 2
ways to start an h2c connection as described in RFC 7540, which are: (1)
create a connection starting with HTTP/1 and then upgrading to h2c [Section 3.2]
and (2) starting a connection directly speaking h2c (aka starting with prior
knowledge) [Section 3.4].

For both of the above connection methods the implementation strategy is to
hijack a HTTP/1 connection, perform the h2c connection on the hijacked
net.Conn, and create a suitably configured net.Conn to pass into
http2.Server.ServeConn.

For h2c with prior knowledge this is relatively simple. For that we just have
to verify the HTTP/2 client preface has been written to the net.Conn, and
then reforward the client preface to the hijacked connection.

For h2c upgraded from HTTP/1, this is a bit more involved. First we validate
the HTTP/1 Upgrade request, and respond to the client with 101 Switching
Protocols. Then we write a HTTP/2 client preface on behalf of the client,
and a settings frame and a headers frame which correspond to what was in
the upgrade request. Then since http2.Server is going respond with a
settings ACK, we swallow it so that it is not forwarded to the client since
for h2c upgrade from HTTP/1 the 101 Switching Protocols response replaces
the settins ACK.

Fixes golang/go#14141

Change-Id: I435f40216c883809c0dcb75426c9c59e2ea31182
Reviewed-on: https://go-review.googlesource.com/112999Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

http2/h2c/h2c_test.go

+// Copyright 2018 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.
+
+package h2c
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"log"
+	"net/http"
+	"testing"
+
+	"golang.org/x/net/http2"
+)
+
+func TestSettingsAckSwallowWriter(t *testing.T) {
+	var buf bytes.Buffer
+	swallower := newSettingsAckSwallowWriter(bufio.NewWriter(&buf))
+	fw := http2.NewFramer(swallower, nil)
+	fw.WriteSettings(http2.Setting{http2.SettingMaxFrameSize, 2})
+	fw.WriteSettingsAck()
+	fw.WriteData(1, true, []byte{})
+	swallower.Flush()
+
+	fr := http2.NewFramer(nil, bufio.NewReader(&buf))
+
+	f, err := fr.ReadFrame()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if f.Header().Type != http2.FrameSettings {
+		t.Fatalf("Expected first frame to be SETTINGS. Got: %v", f.Header().Type)
+	}
+
+	f, err = fr.ReadFrame()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if f.Header().Type != http2.FrameData {
+		t.Fatalf("Expected first frame to be DATA. Got: %v", f.Header().Type)
+	}
+}
+
+func ExampleNewHandler() {
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, "Hello world")
+	})
+	h2s := &http2.Server{
+		// ...
+	}
+	h1s := &http.Server{
+		Addr:    ":8080",
+		Handler: NewHandler(handler, h2s),
+	}
+	log.Fatal(h1s.ListenAndServe())
+}