Make HTTP middleware easier to use

server/settings/admin/index.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"
         "sort"
         "time"
 
         "github.com/dustin/go-humanize"
-        "github.com/julienschmidt/httprouter"
-        "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/clock"
+        "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/settings"
         "github.com/luci/luci-go/server/templates"
 )
 
 type pageIndexEntry struct {
         ID    string
         Title string
 }
 
 type pageIndexEntries []pageIndexEntry
 
 func (a pageIndexEntries) Len() int           { return len(a) }
 func (a pageIndexEntries) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 func (a pageIndexEntries) Less(i, j int) bool { return a[i].Title < a[j].Title }
 
-func indexPage(c context.Context, rw http.ResponseWriter, r *http.Request, p httprouter.Params) {
+func indexPage(c *router.Context) {
         entries := pageIndexEntries{}
         for id, p := range settings.GetUIPages() {
-                title, err := p.Title(c)
+                title, err := p.Title(c.Context)
                 if err != nil {
-                        replyError(c, rw, err)
+                        replyError(c.Context, c.Writer, err)
+                        c.Abort()
                         return
                 }
                 entries = append(entries, pageIndexEntry{
                         ID:    id,
                         Title: title,
                 })
         }
         sort.Sort(entries)
 
         // Grab timestamp when last settings change hits all instances.
         consistencyTime := time.Time{}
-        if s := settings.GetSettings(c); s != nil {
+        if s := settings.GetSettings(c.Context); s != nil {
                 if storage, _ := s.GetStorage().(settings.EventualConsistentStorage); storage != nil {
                         var err error
-                        if consistencyTime, err = storage.GetConsistencyTime(c); err != nil {
-                                replyError(c, rw, err)
+                        if consistencyTime, err = storage.GetConsistencyTime(c.Context); err != nil {
+                                replyError(c.Context, c.Writer, err)
+                                c.Abort()
                                 return
                         }
                 }
         }
 
-        now := clock.Now(c).UTC()
-        templates.MustRender(c, rw, "pages/index.html", templates.Args{
+        now := clock.Now(c.Context).UTC()
+        templates.MustRender(c.Context, c.Writer, "pages/index.html", templates.Args{
                 "Entries":               entries,
                 "WaitingForConsistency": !consistencyTime.IsZero() && now.Before(consistencyTime),
                 "TimeToConsistency":     humanize.RelTime(consistencyTime, now, "", ""),
         })
 }