Milo Refactor: Remove theme support

milo/appengine/logdog/build.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 logdog
 
 import (
+        "errors"
         "fmt"
-        "net/http"
         "time"
 
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/proto/google"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/logdog/api/logpb"
         "github.com/luci/luci-go/logdog/client/coordinator"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/logdog/common/viewer"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
         "github.com/luci/luci-go/milo/api/resp"
         "github.com/luci/luci-go/milo/appengine/logdog/internal"
-        "github.com/luci/luci-go/milo/common/miloerror"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 )
 
 const (
         // intermediateCacheLifetime is the amount of time to cache intermediate (non-
         // terminal) annotation streams. Terminal annotation streams are cached
         // indefinitely.
         intermediateCacheLifetime = 10 * time.Second
@@ skipping 21 matching lines @@
                 return fmt.Errorf("Invalid project name: %s", as.Project)
         }
 
         if err := as.Path.Validate(); err != nil {
                 return fmt.Errorf("Invalid log stream path %q: %s", as.Path, err)
         }
 
         return nil
 }
 
+var errNotMilo = errors.New("Requested stream is not a Milo annotation protobuf")
+var errNotDatagram = errors.New("Requested stream is not a datagram stream")
+var errNoEntries = errors.New("Log stream has no annotation entries")
+
 // Fetch loads the annotation stream from LogDog.
 //
 // If the stream does not exist, or is invalid, Fetch will return a Milo error.
 // Otherwise, it will return the Step that was loaded.
 //
 // Fetch caches the step, so multiple calls to Fetch will return the same Step
 // value.
 func (as *AnnotationStream) Fetch(c context.Context) (*miloProto.Step, error) {
         // Cached?
         if as.cs.Step != nil {
@@ skipping 14 matching lines @@
 
         le, err := stream.Tail(c, coordinator.WithState(&state), coordinator.Complete())
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to load stream.")
                 return nil, err
         }
 
         // Make sure that this is an annotation stream.
         switch {
         case state.Desc.ContentType != miloProto.ContentTypeAnnotations:
-                return nil, &miloerror.Error{
-                        Message: "Requested stream is not a Milo annotation protobuf",
-                        Code:    http.StatusBadRequest,
-                }
+                return nil, errNotMilo
 
         case state.Desc.StreamType != logpb.StreamType_DATAGRAM:
-                return nil, &miloerror.Error{
-                        Message: "Requested stream is not a datagram stream",
-                        Code:    http.StatusBadRequest,
-                }
+                return nil, errNotDatagram
 
         case le == nil:
                 // No annotation stream data, so render a minimal page.
-                return nil, &miloerror.Error{
-                        Message: "Log stream has no annotation entries",
-                        Code:    http.StatusNotFound,
-                }
+                return nil, errNoEntries
         }
 
         // Get the last log entry in the stream. In reality, this will be index 0,
         // since the "Tail" call should only return one log entry.
         //
         // Because we supplied the "Complete" flag to Tail and suceeded, this datagram
         // will be complete even if its source datagram(s) are fragments.
         dg := le.GetDatagram()
         if dg == nil {
-                return nil, &miloerror.Error{
-                        Message: "Datagram stream does not have datagram data",
-                        Code:    http.StatusInternalServerError,
-                }
+                return nil, errors.New("Datagram stream does not have datagram data")
         }
 
         // Attempt to decode the Step protobuf.
         var step miloProto.Step
         if err := proto.Unmarshal(dg.Data, &step); err != nil {
-                return nil, &miloerror.Error{
-                        Message: "Failed to unmarshal annotation protobuf",
-                        Code:    http.StatusInternalServerError,
-                }
+                return nil, err
         }
 
         var latestEndedTime time.Time
         for _, sub := range step.Substep {
                 switch t := sub.Substep.(type) {
                 case *miloProto.Step_Substep_AnnotationStream:
                         // TODO(hinoka,dnj): Implement recursive / embedded substream fetching if
                         // specified.
                         log.Warningf(c, "Annotation stream links LogDog substream [%+v], not supported!", t.AnnotationStream)
 
@@ skipping 85 matching lines @@
                 if link.Label == "" {
                         link.Label = "unnamed"
                 }
                 return &link
 
         default:
                 // Don't know how to render.
                 return nil
         }
 }