Make HTTP middleware easier to use

server/settings/admin/settings.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package admin
 
 import (
         "net/http"
 
         "github.com/julienschmidt/httprouter"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/xsrf"
+        "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/settings"
         "github.com/luci/luci-go/server/templates"
 )
 
 type fieldWithValue struct {
         settings.UIField
         Value string
 }
 
 type validationError struct {
@@ skipping 12 matching lines @@
                 templates.MustRender(c, rw, "pages/error.html", templates.Args{
                         "Error": "No such settings",
                 })
                 return
         }
         if err := cb(id, page); err != nil {
                 replyError(c, rw, err)
         }
 }
 
-func settingsPageGET(c context.Context, rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
-        withPage(c, rw, p, func(id string, page settings.UIPage) error {
-                title, err := page.Title(c)
+func settingsPageGET(c *router.Context) {
+        withPage(c.Context, c.Writer, c.Params, func(id string, page settings.UIPage) error {
+                title, err := page.Title(c.Context)
                 if err != nil {
                         return err
                 }
-                overview, err := page.Overview(c)
+                overview, err := page.Overview(c.Context)
                 if err != nil {
                         return err
                 }
-                fields, err := page.Fields(c)
+                fields, err := page.Fields(c.Context)
                 if err != nil {
                         return err
                 }
-                values, err := page.ReadSettings(c)
+                values, err := page.ReadSettings(c.Context)
                 if err != nil {
                         return err
                 }
 
                 withValues := make([]fieldWithValue, len(fields))
                 for i, f := range fields {
                         withValues[i] = fieldWithValue{
                                 UIField: f,
                                 Value:   values[f.ID],
                         }
                 }
 
-                templates.MustRender(c, rw, "pages/settings.html", templates.Args{
+                templates.MustRender(c.Context, c.Writer, "pages/settings.html", templates.Args{
                         "ID":             id,
                         "Title":          title,
                         "Overview":       overview,
                         "Fields":         withValues,
-                        "XsrfTokenField": xsrf.TokenField(c),
+                        "XsrfTokenField": xsrf.TokenField(c.Context),
                 })
                 return nil
         })
 }
 
-func settingsPagePOST(c context.Context, rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
-        withPage(c, rw, p, func(id string, page settings.UIPage) error {
-                title, err := page.Title(c)
+func settingsPagePOST(c *router.Context) {
+        withPage(c.Context, c.Writer, c.Params, func(id string, page settings.UIPage) error {
+                title, err := page.Title(c.Context)
                 if err != nil {
                         return err
                 }
-                fields, err := page.Fields(c)
+                fields, err := page.Fields(c.Context)
                 if err != nil {
                         return err
                 }
 
                 // Extract values from the page and validate them.
                 values := make(map[string]string, len(fields))
                 validationErrors := []validationError{}
                 for _, f := range fields {
                         if !f.Type.IsEditable() {
                                 continue
                         }
-                        val := r.PostFormValue(f.ID)
+                        val := c.Request.PostFormValue(f.ID)
                         values[f.ID] = val
                         if f.Validator != nil {
                                 if err := f.Validator(val); err != nil {
                                         validationErrors = append(validationErrors, validationError{
                                                 FieldTitle: f.Title,
                                                 Value:      val,
                                                 Error:      err.Error(),
                                         })
                                 }
                         }
                 }
                 if len(validationErrors) != 0 {
-                        rw.WriteHeader(http.StatusBadRequest)
-                        templates.MustRender(c, rw, "pages/validation_error.html", templates.Args{
+                        c.Writer.WriteHeader(http.StatusBadRequest)
+                        templates.MustRender(c.Context, c.Writer, "pages/validation_error.html", templates.Args{
                                 "ID":     id,
                                 "Title":  title,
                                 "Errors": validationErrors,
                         })
                         return nil
                 }
 
                 // Store.
-                err = page.WriteSettings(c, values, auth.CurrentUser(c).Email, "modified via web UI")
+                err = page.WriteSettings(c.Context, values, auth.CurrentUser(c.Context).Email, "modified via web UI")
                 if err != nil {
                         return err
                 }
-                templates.MustRender(c, rw, "pages/done.html", templates.Args{
+                templates.MustRender(c.Context, c.Writer, "pages/done.html", templates.Args{
                         "ID":    id,
                         "Title": title,
                 })
                 return nil
         })
 }