[errors] Greatly simplify common/errors package.

dm/appengine/deps/ensure_graph_data.go

 // Copyright 2015 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 deps
 
 import (
         "fmt"
 
         "golang.org/x/net/context"
@@ skipping 125 matching lines @@
                 }
                 muts = append(muts, mut)
         }
         for qid, nums := range newAttempts.To {
                 muts = append(muts, &mutate.EnsureQuestAttempts{
                         Quest:           &model.Quest{ID: qid},
                         AIDs:            nums.Nums,
                         DoNotMergeQuest: true,
                 })
         }
-        return grpcAnnotate(tumble.AddToJournal(c, muts...), codes.Internal).
-                Reason("attempting to journal").Err()
+        return grpcAnnotate(tumble.AddToJournal(c, muts...), codes.Internal, "attempting to journal").Err()
 }
 
 func (d *deps) ensureGraphData(c context.Context, req *dm.EnsureGraphDataReq, newQuests []*model.Quest, newAttempts *dm.AttemptList, rsp *dm.EnsureGraphDataRsp) (err error) {
         var (
                 fwdDepExists *ds.ExistsResult
                 fwdDepKeys   []*ds.Key
         )
         if req.ForExecution != nil {
                 fwdDepKeys = model.FwdDepKeysFromList(c, req.ForExecution.Id.AttemptID(), newAttempts)
         }
@@ skipping 11 matching lines @@
                         gen <- func() (err error) {
                                 fwdDepExists, err = ds.Exists(c, fwdDepKeys)
                                 if err != nil {
                                         err = fmt.Errorf("while finding FwdDeps: %s", err)
                                 }
                                 return err
                         }
                 }
         })
         if err != nil {
-                return grpcAnnotate(err, codes.Internal).Reason("failed to gather prerequisites").Err()
+                return grpcAnnotate(err, codes.Internal, "failed to gather prerequisites").Err()
         }
 
         // Now that we've walked the graph, prune the lists of new Quest and Attempts
         // by the information retrieved in the graph walk. newQuest and newAttempts
         // will be reduced to contain only the missing information.
         newQuests, newQuestSet := filterQuestsByNewTemplateData(rsp.Result, newQuests)
         newAttempts, newAttemptsLen, err := filterAttemptsByDNE(rsp.Result, newAttempts, newQuestSet)
         if err != nil {
-                return grpcAnnotate(err, codes.InvalidArgument).Reason("filterAttemptsByDNE").Err()
+                return grpcAnnotate(err, codes.InvalidArgument, "filterAttemptsByDNE").Err()
         }
 
         // we're just asserting nodes, no edges, so journal whatever's left
         if req.ForExecution == nil {
                 logging.Fields{"qs": len(newQuests), "atmpts": newAttemptsLen}.Infof(c,
                         "journaling without deps")
                 err := journalQuestAttempts(c, newQuests, newAttempts)
                 rsp.Accepted = err == nil
                 return err
         }
@@ skipping 93 matching lines @@
 
                 d, ok := dists[qDesc.DistributorConfigName]
                 if !ok {
                         if d, _, err = reg.MakeDistributor(c, qDesc.DistributorConfigName); err != nil {
                                 return
                         }
                         dists[qDesc.DistributorConfigName] = d
                 }
 
                 if err = d.Validate(qDesc.DistributorParameters); err != nil {
-                        err = grpcAnnotate(err, codes.InvalidArgument).
-                                Reason("JSON distributor parameters are invalid for this distributor configuration.").Err()
+                        err = grpcAnnotate(err, codes.InvalidArgument,
+                                "JSON distributor parameters are invalid for this distributor configuration.").Err()
                         return
                 }
 
                 if _, ok := newQuests[q.ID]; !ok {
                         newQuests[q.ID] = q
                 }
                 rsp.QuestIds = append(rsp.QuestIds, dm.NewQuestID(q.ID))
                 anums := newAttempts.To[q.ID]
                 if anums == nil {
                         anums = &dm.AttemptList_Nums{}
@@ skipping 47 matching lines @@
         }
 
         return
 }
 
 func (d *deps) EnsureGraphData(c context.Context, req *dm.EnsureGraphDataReq) (rsp *dm.EnsureGraphDataRsp, err error) {
         if req.ForExecution != nil {
                 logging.Fields{"execution": req.ForExecution.Id}.Infof(c, "on behalf of")
                 _, _, err := model.AuthenticateExecution(c, req.ForExecution)
                 if err != nil {
-                        return nil, grpcAnnotate(err, codes.Unauthenticated).Reason("bad execution auth").Err()
+                        return nil, grpcAnnotate(err, codes.Unauthenticated, "bad execution auth").Err()
                 }
         } else {
                 if err = canWrite(c); err != nil {
                         return
                 }
         }
 
         // render any quest descriptions, templates and template attempts into
         // a single merged set of new quests and new attempts
         rsp, newQuests, newAttempts, err := renderRequest(c, req)
         if err != nil || len(rsp.TemplateError) > 0 {
                 return
         }
 
         newQuestList := make([]*model.Quest, 0, len(newQuests))
         for _, q := range newQuests {
                 newQuestList = append(newQuestList, q)
         }
 
         err = d.ensureGraphData(c, req, newQuestList, newAttempts, rsp)
 
         return
 }