Milo Refactor: Remove theme support

milo/appengine/buildbucket/builder.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 buildbucket
 
 import (
         "encoding/json"
         "fmt"
         "net/url"
@@ skipping 201 matching lines @@
                                 target.FinishedBuilds = append(target.FinishedBuilds, mb)
                         }
 
                 default:
                         panic("impossible")
                 }
         }
         return nil
 }
 
+type builderQuery struct {
+        Server  string
+        Bucket  string
+        Builder string
+        Limit   int
+}
+
 // builderImpl is the implementation for getting a milo builder page from buildbucket.
 // if maxCompletedBuilds < 0, 25 is used.
-func builderImpl(c context.Context, server, bucket, builder string, maxCompletedBuilds int) (*resp.Builder, error) {
-        if maxCompletedBuilds < 0 {
-                maxCompletedBuilds = 20
+func builderImpl(c context.Context, q builderQuery) (*resp.Builder, error) {
+        if q.Limit < 0 {
+                q.Limit = 20
         }
 
         result := &resp.Builder{
-                Name: builder,
+                Name: q.Builder,
         }
-        if server == "debug" {
-                return result, getDebugBuilds(c, bucket, builder, maxCompletedBuilds, result)
+        if q.Server == "debug" {
+                return result, getDebugBuilds(c, q.Bucket, q.Builder, q.Limit, result)
         }
-        client, err := newBuildbucketClient(c, server)
+        client, err := newBuildbucketClient(c, q.Server)
         if err != nil {
                 return nil, err
         }
 
         fetch := func(target *[]*resp.BuildSummary, status string, count int) error {
-                builds, err := fetchBuilds(c, client, bucket, builder, status, count)
+                builds, err := fetchBuilds(c, client, q.Bucket, q.Builder, status, count)
                 if err != nil {
                         log.Errorf(c, "Could not fetch builds with status %s: %s", status, err)
                         return err
                 }
                 *target = make([]*resp.BuildSummary, len(builds))
                 for i, bb := range builds {
                         (*target)[i] = toMiloBuild(c, bb)
                 }
                 return nil
         }
         // fetch pending, current and finished builds concurrently.
         // Why not a single request? Because we need different build number
         // limits for different statuses.
         return result, parallel.FanOutIn(func(work chan<- func() error) {
                 work <- func() error {
                         return fetch(&result.PendingBuilds, StatusScheduled, -1)
                 }
                 work <- func() error {
                         return fetch(&result.CurrentBuilds, StatusStarted, -1)
                 }
                 work <- func() error {
-                        return fetch(&result.FinishedBuilds, StatusCompleted, maxCompletedBuilds)
+                        return fetch(&result.FinishedBuilds, StatusCompleted, q.Limit)
                 }
         })
 }
 
 // parseTimestamp converts buildbucket timestamp in microseconds to time.Time
 func parseTimestamp(microseconds int64) time.Time {
         if microseconds == 0 {
                 return time.Time{}
         }
         return time.Unix(microseconds/1e6, microseconds%1e6*1000).UTC()
 }
 
 type newBuildsFirst []*resp.BuildSummary
 
 func (a newBuildsFirst) Len() int      { return len(a) }
 func (a newBuildsFirst) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
 func (a newBuildsFirst) Less(i, j int) bool {
         return a[i].PendingTime.Started.After(a[j].PendingTime.Started)
 }