type ResponseWriter interface { 	// 	// If the ResponseWriter has already been written to, then this method panics. 	Redirect(r *IncomingRequest, url string, code StatusCode) Result+} +// ResponseHeadersWriter is used to alter the HTTP response headers.+//+// A ResponseHeadersWriter may not be used after the Handler.ServeHTTP method has returned.+type ResponseHeadersWriter interface {

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"fmt"+	"net/http"+)++// TODO(kele): come up with a better name than this.

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"fmt"+	"net/http"+)++// TODO(kele): come up with a better name than this.+type task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	// TODO(kele): we need to distinguish between calling Write and actually+	// writing to the net/http.ResponseWriter.+	written      bool+	writtenError bool+}++// DeprecatedNewResponseWriter creates a ResponseWriter implementation that has+// been historically used for testing. DO NOT USE this function, it's going+// to be removed soon.+//+// The main problem with this is the implementation of the returned+// ResponseWriter is incomplete, i.e. lacks the Handler and Interceptors fields+// of the HandlerConfig needed by the task. For the existing tests that use it,+// it's fine, but they should be migrated.+//+// TODO(kele): remove this once we have a better option to provide a+// ResponseWriter implementation for interceptor testing.+func DeprecatedNewResponseWriter(rw http.ResponseWriter, dispatcher Dispatcher) ResponseWriter {+	return &task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++// HandlerConfig is the safe HTTP handler configuration, including the+// dispatcher and interceptors.+type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func processRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}++// WriteError writes an error response (400-599) according to the provided+// status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) WriteError(code StatusCode) Result {+	// TODO: accept custom error responses that need to go through the dispatcher.+	if t.writtenError {+		panic("ResponseWriter.WriteError called twice")+	}+	t.written = true+	t.writtenError = true+	resp := &ErrorResponse{Code: code}+	t.errorPhase(resp)+	http.Error(t.rw, http.StatusText(int(resp.Code)), int(resp.Code))+	return Result{}+}++// Redirect responds with a redirect to the given url, using code as the status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) Redirect(r *IncomingRequest, url string, code StatusCode) Result {+	if code < 300 || code >= 400 {+		panic("wrong method called")+	}+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	http.Redirect(t.rw, r.req, url, int(code))+	return Result{}+}++// Header returns the collection of headers that will be set+// on the response. Headers must be set before writing a+// response (e.g. Write, WriteTemplate).+func (t *Task) Header() Header {+	return t.header+}++// SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.+// The provided cookie must have a valid Name, otherwise an error will be+// returned.+func (t *Task) SetCookie(c *Cookie) error {+	return t.header.addCookie(c)+}++// SetCode allows setting a response status. If the response was already+// written, trying to set the status code will have no effect. This method will+// panic if an invalid status code is passed (i.e. not in the range 1XX-5XX).+//+// If SetCode was called before NoContent, Redirect or WriteError, the status+// code set by the latter will be the actual response status.+//+// TODO(empijei@, kele@, maramihali@): decide what should be done if the+// code passed is either 3XX (redirect) or 4XX-5XX (client/server error).+func (t *Task) SetCode(code StatusCode) {+	if t.written {+		return+	}+	if code < 100 || code >= 600 {+		panic("invalid status code")+	}+	t.code = code+}++// commitPhase calls the Commit phases of all the interceptors. This stage will+// run before a response is written to the ResponseWriter. If a response is+// written to the ResponseWriter in a Commit phase then the Commit phases of the+// remaining interceptors won't execute.+//+// TODO: BIG WARNING, if ResponseWriter.Write and ResponseWriter.WriteTemplate+// are called in Commit then this will recurse. CommitResponseWriter was an+// attempt to prevent this by not giving access to Write and WriteTemplate in+// the Commit phase.+func (t *Task) commitPhase(resp Response) {+	for i := len(t.cfg.Interceptors) - 1; i >= 0; i-- {+		t.cfg.Interceptors[i].Commit(t, t.req, resp)+	}+}++// errorPhase calls the OnError phases of all the interceptors associated with+// a handler. This stage runs before an error response is written to the+// ResponseWriter.+//+// TODO: BIG WARNING, if an interceptor attempts to write to the ResponseWriter+// in the OnError phase will result in an irrecoverable error.+func (t *Task) errorPhase(resp Response) {+	for i := len(t.cfg.Interceptors) - 1; i >= 0; i-- {+		t.cfg.Interceptors[i].OnError(t, t.req, resp)

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}++// WriteError writes an error response (400-599) according to the provided+// status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) WriteError(code StatusCode) Result {+	// TODO: accept custom error responses that need to go through the dispatcher.+	if t.writtenError {+		panic("ResponseWriter.WriteError called twice")+	}+	t.written = true+	t.writtenError = true+	resp := &ErrorResponse{Code: code}+	t.errorPhase(resp)+	http.Error(t.rw, http.StatusText(int(resp.Code)), int(resp.Code))+	return Result{}+}++// Redirect responds with a redirect to the given url, using code as the status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) Redirect(r *IncomingRequest, url string, code StatusCode) Result {+	if code < 300 || code >= 400 {+		panic("wrong method called")+	}+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	http.Redirect(t.rw, r.req, url, int(code))+	return Result{}+}++// Header returns the collection of headers that will be set+// on the response. Headers must be set before writing a+// response (e.g. Write, WriteTemplate).+func (t *Task) Header() Header {+	return t.header+}++// SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.+// The provided cookie must have a valid Name, otherwise an error will be+// returned.+func (t *Task) SetCookie(c *Cookie) error {+	return t.header.addCookie(c)+}++// SetCode allows setting a response status. If the response was already+// written, trying to set the status code will have no effect. This method will+// panic if an invalid status code is passed (i.e. not in the range 1XX-5XX).+//+// If SetCode was called before NoContent, Redirect or WriteError, the status+// code set by the latter will be the actual response status.+//+// TODO(empijei@, kele@, maramihali@): decide what should be done if the+// code passed is either 3XX (redirect) or 4XX-5XX (client/server error).+func (t *Task) SetCode(code StatusCode) {+	if t.written {+		return+	}+	if code < 100 || code >= 600 {+		panic("invalid status code")+	}+	t.code = code+}++// commitPhase calls the Commit phases of all the interceptors. This stage will+// run before a response is written to the ResponseWriter. If a response is+// written to the ResponseWriter in a Commit phase then the Commit phases of the+// remaining interceptors won't execute.+//+// TODO: BIG WARNING, if ResponseWriter.Write and ResponseWriter.WriteTemplate+// are called in Commit then this will recurse. CommitResponseWriter was an+// attempt to prevent this by not giving access to Write and WriteTemplate in+// the Commit phase.+func (t *Task) commitPhase(resp Response) {+	for i := len(t.cfg.Interceptors) - 1; i >= 0; i-- {+		t.cfg.Interceptors[i].Commit(t, t.req, resp)+	}+}++// errorPhase calls the OnError phases of all the interceptors associated with+// a handler. This stage runs before an error response is written to the+// ResponseWriter.+//+// TODO: BIG WARNING, if an interceptor attempts to write to the ResponseWriter+// in the OnError phase will result in an irrecoverable error.+func (t *Task) errorPhase(resp Response) {+	for i := len(t.cfg.Interceptors) - 1; i >= 0; i-- {+		t.cfg.Interceptors[i].OnError(t, t.req, resp)

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}++// WriteError writes an error response (400-599) according to the provided+// status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) WriteError(code StatusCode) Result {+	// TODO: accept custom error responses that need to go through the dispatcher.+	if t.writtenError {+		panic("ResponseWriter.WriteError called twice")+	}+	t.written = true+	t.writtenError = true+	resp := &ErrorResponse{Code: code}+	t.errorPhase(resp)+	http.Error(t.rw, http.StatusText(int(resp.Code)), int(resp.Code))+	return Result{}+}++// Redirect responds with a redirect to the given url, using code as the status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) Redirect(r *IncomingRequest, url string, code StatusCode) Result {+	if code < 300 || code >= 400 {+		panic("wrong method called")+	}+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	http.Redirect(t.rw, r.req, url, int(code))+	return Result{}+}++// Header returns the collection of headers that will be set+// on the response. Headers must be set before writing a+// response (e.g. Write, WriteTemplate).+func (t *Task) Header() Header {+	return t.header+}++// SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.+// The provided cookie must have a valid Name, otherwise an error will be+// returned.+func (t *Task) SetCookie(c *Cookie) error {+	return t.header.addCookie(c)+}++// SetCode allows setting a response status. If the response was already+// written, trying to set the status code will have no effect. This method will+// panic if an invalid status code is passed (i.e. not in the range 1XX-5XX).+//+// If SetCode was called before NoContent, Redirect or WriteError, the status+// code set by the latter will be the actual response status.+//+// TODO(empijei@, kele@, maramihali@): decide what should be done if the+// code passed is either 3XX (redirect) or 4XX-5XX (client/server error).+func (t *Task) SetCode(code StatusCode) {+	if t.written {+		return+	}+	if code < 100 || code >= 600 {+		panic("invalid status code")+	}+	t.code = code+}++// commitPhase calls the Commit phases of all the interceptors. This stage will+// run before a response is written to the ResponseWriter. If a response is+// written to the ResponseWriter in a Commit phase then the Commit phases of the+// remaining interceptors won't execute.+//+// TODO: BIG WARNING, if ResponseWriter.Write and ResponseWriter.WriteTemplate+// are called in Commit then this will recurse. CommitResponseWriter was an+// attempt to prevent this by not giving access to Write and WriteTemplate in+// the Commit phase.

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}++// WriteError writes an error response (400-599) according to the provided+// status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) WriteError(code StatusCode) Result {+	// TODO: accept custom error responses that need to go through the dispatcher.+	if t.writtenError {+		panic("ResponseWriter.WriteError called twice")+	}+	t.written = true+	t.writtenError = true+	resp := &ErrorResponse{Code: code}+	t.errorPhase(resp)+	http.Error(t.rw, http.StatusText(int(resp.Code)), int(resp.Code))+	return Result{}+}++// Redirect responds with a redirect to the given url, using code as the status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) Redirect(r *IncomingRequest, url string, code StatusCode) Result {+	if code < 300 || code >= 400 {+		panic("wrong method called")+	}+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	http.Redirect(t.rw, r.req, url, int(code))+	return Result{}+}++// Header returns the collection of headers that will be set+// on the response. Headers must be set before writing a+// response (e.g. Write, WriteTemplate).

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}++// WriteError writes an error response (400-599) according to the provided+// status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) WriteError(code StatusCode) Result {+	// TODO: accept custom error responses that need to go through the dispatcher.+	if t.writtenError {+		panic("ResponseWriter.WriteError called twice")+	}+	t.written = true+	t.writtenError = true+	resp := &ErrorResponse{Code: code}+	t.errorPhase(resp)+	http.Error(t.rw, http.StatusText(int(resp.Code)), int(resp.Code))+	return Result{}+}++// Redirect responds with a redirect to the given url, using code as the status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) Redirect(r *IncomingRequest, url string, code StatusCode) Result {+	if code < 300 || code >= 400 {+		panic("wrong method called")

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}++// WriteError writes an error response (400-599) according to the provided+// status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) WriteError(code StatusCode) Result {+	// TODO: accept custom error responses that need to go through the dispatcher.+	if t.writtenError {+		panic("ResponseWriter.WriteError called twice")+	}+	t.written = true+	t.writtenError = true+	resp := &ErrorResponse{Code: code}+	t.errorPhase(resp)+	http.Error(t.rw, http.StatusText(int(resp.Code)), int(resp.Code))+	return Result{}+}++// Redirect responds with a redirect to the given url, using code as the status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) Redirect(r *IncomingRequest, url string, code StatusCode) Result {+	if code < 300 || code >= 400 {+		panic("wrong method called")+	}+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	http.Redirect(t.rw, r.req, url, int(code))+	return Result{}+}++// Header returns the collection of headers that will be set+// on the response. Headers must be set before writing a+// response (e.g. Write, WriteTemplate).+func (t *Task) Header() Header {+	return t.header+}++// SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.+// The provided cookie must have a valid Name, otherwise an error will be+// returned.+func (t *Task) SetCookie(c *Cookie) error {

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}++// WriteError writes an error response (400-599) according to the provided+// status code.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) WriteError(code StatusCode) Result {+	// TODO: accept custom error responses that need to go through the dispatcher.+	if t.writtenError {+		panic("ResponseWriter.WriteError called twice")+	}+	t.written = true

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {+	rw  http.ResponseWriter+	req *IncomingRequest++	cfg HandlerConfig++	code   StatusCode+	header Header++	written      bool+	writtenError bool+}++// NewTask creates a ResponseWriter from a safehttp.Dispatcher, an+// http.ResponseWriter and a reference to the current IncomingRequest being served.+// The IncomingRequest will only be used by the commit phase, which only runs when+// the ServeMux is used, and can be passed as nil in tests.+// TODO: remove the IncomingRequest parameter.++// ProperNewTask TODO+func BrokenNewTask(rw http.ResponseWriter, dispatcher Dispatcher) *Task {+	return &Task{+		cfg:    HandlerConfig{Dispatcher: dispatcher},+		rw:     rw,+		header: newHeader(rw.Header()),+	}+}++type HandlerConfig struct {+	Handler      Handler+	Dispatcher   Dispatcher+	Interceptors []ConfiguredInterceptor+}++func ProcessRequest(cfg HandlerConfig, rw http.ResponseWriter, req *http.Request) {+	t := &Task{+		cfg:    cfg,+		rw:     rw,+		header: newHeader(rw.Header()),+		req:    NewIncomingRequest(req),+	}++	// The `net/http` package recovers handler panics, but we cannot rely on that behavior here.+	// The reason is, we might need to run After/Commit stages of the interceptors before we+	// respond with a 500 Internal Server Error.+	defer func() {+		if r := recover(); r != nil {+			t.WriteError(StatusInternalServerError)+		}+	}()++	for _, it := range t.cfg.Interceptors {+		it.Before(t, t.req)+		if t.written {+			return+		}+	}++	t.cfg.Handler.ServeHTTP(t, t.req)+	if !t.written {+		t.NoContent()+	}+}++// Write dispatches the response to the Dispatcher. This will be written to the+// underlying http.ResponseWriter if the Dispatcher decides it's safe to do so.+//+// TODO: replace panics with proper error handling when writing the response fails.+func (t *Task) Write(resp Response) Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(resp)++	ct, err := t.cfg.Dispatcher.ContentType(resp)+	if err != nil {+		panic(err)+	}+	t.rw.Header().Set("Content-Type", ct)++	if t.code == 0 {+		t.code = StatusOK+	}+	t.rw.WriteHeader(int(t.code))++	if err := t.cfg.Dispatcher.Write(t.rw, resp); err != nil {+		panic(err)+	}+	return Result{}+}++// NoContent responds with a 204 No Content response.+//+// If the ResponseWriter has already been written to, then this method will panic.+func (t *Task) NoContent() Result {+	if t.written {+		panic("ResponseWriter was already written to")+	}+	t.written = true+	t.commitPhase(NoContentResponse{})+	t.rw.WriteHeader(int(StatusNoContent))+	return Result{}+}

 func (s *ServeMuxConfig) Intercept(i Interceptor) {  // Mux returns the ServeMux with a copy of the current configuration. func (s *ServeMuxConfig) Mux() *ServeMux {-	m := newServeMux(s.dispatcher)-	for _, it := range s.interceptors {-		m.install(it)+	dispatcher := s.dispatcher+	if dispatcher == nil {+		dispatcher = DefaultDispatcher{} 	}+	// pattern -> method -> HandlerConfig+	handlers := map[string]map[string]HandlerConfig{} 	for _, hr := range s.handlers {-		m.handle(hr.pattern, hr.method, hr.handler, hr.cfgs...)+		if handlers[hr.pattern] == nil {+			handlers[hr.pattern] = map[string]HandlerConfig{}+		}+		if _, ok := handlers[hr.pattern][hr.method]; ok {+			panic(fmt.Sprintf("double registration of (pattern = %q, method = %q)", hr.pattern, hr.method))+		}+		handlers[hr.pattern][hr.method] =+			HandlerConfig{+				Dispatcher:   dispatcher,+				Handler:      hr.handler,+				Interceptors: configureInterceptors(s.interceptors, hr.cfgs),+			} 	}-	return m+	m := http.NewServeMux()+	registerHandlers(m, handlers)+	return &ServeMux{mux: m}+}++func configureInterceptors(interceptors []Interceptor, cfgs []InterceptorConfig) []ConfiguredInterceptor {+	var its []ConfiguredInterceptor+	for _, it := range interceptors {+		var cfg InterceptorConfig+		for _, c := range cfgs {+			if c.Match(it) {

+// Copyright 2020 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// 	https://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package safehttp++import (+	"net/http"+)++type Task struct {

 func (s *ServeMuxConfig) Intercept(i Interceptor) {  // Mux returns the ServeMux with a copy of the current configuration. func (s *ServeMuxConfig) Mux() *ServeMux {-	m := newServeMux(s.dispatcher)-	for _, it := range s.interceptors {-		m.install(it)+	dispatcher := s.dispatcher+	if dispatcher == nil {+		dispatcher = DefaultDispatcher{} 	}+	// pattern -> method -> HandlerConfig+	handlers := map[string]map[string]HandlerConfig{} 	for _, hr := range s.handlers {-		m.handle(hr.pattern, hr.method, hr.handler, hr.cfgs...)+		if handlers[hr.pattern] == nil {+			handlers[hr.pattern] = map[string]HandlerConfig{}+		}+		if _, ok := handlers[hr.pattern][hr.method]; ok {+			panic(fmt.Sprintf("double registration of (pattern = %q, method = %q)", hr.pattern, hr.method))

 const ( // Multiple handlers can be registered for a single pattern, as long as they // handle different HTTP methods. type ServeMux struct {-	mux  *http.ServeMux-	disp Dispatcher--	// Maps patterns to handlers supporting multiple HTTP methods.-	handlers  map[string]standardHandler-	interceps []Interceptor-}--// newServeMux allocates and returns a new ServeMux. If the provided dispatcher-// is nil, the DefaultDispatcher is used.-func newServeMux(d Dispatcher) *ServeMux {-	if d == nil {-		d = DefaultDispatcher{}-	}-	return &ServeMux{-		mux:      http.NewServeMux(),-		disp:     d,-		handlers: map[string]standardHandler{},-	}-}--func (m *ServeMux) handle(pattern string, method string, h Handler, cfgs ...InterceptorConfig) {-	var interceps []ConfiguredInterceptor-	for _, it := range m.interceps {-		var cfg InterceptorConfig-		for _, c := range cfgs {-			if c.Match(it) {-				cfg = c-				break+	mux *http.ServeMux+}++func registerHandlers(mux *http.ServeMux, handlers map[string]map[string]HandlerConfig) {+	for pattern, handlersPerMethod := range handlers {+		pattern := pattern