[errors] Greatly simplify common/errors package.

dm/appengine/distributor/swarming/v1/isolate.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 swarming
 
 import (
         "bytes"
         "encoding/json"
         "strings"
@@ skipping 76 matching lines @@
                         Digest: string(chnk.file.Digest), Size: *chnk.file.Size,
                         IsIsolated: chnk.isIso}
         }
 
         anonC, authC := httpClients(c)
 
         isoClient := isolatedclient.New(
                 anonC, authC, isolateURL, isolatedclient.DefaultNamespace, nil, nil)
         states, err := isoClient.Contains(c, dgsts)
         if err != nil {
-                err = errors.Annotate(err).
-                        D("count", len(dgsts)).
-                        Reason("checking containment for %(count)d digests").
-                        Err()
+                err = errors.Annotate(err, "checking containment for %d digests", len(dgsts)).Err()
                 return err
         }
         return parallel.FanOutIn(func(ch chan<- func() error) {
                 for i, st := range states {
                         if st != nil {
                                 i, st := i, st
                                 ch <- func() error {
                                         return isoClient.Push(c, st, isolatedclient.NewBytesSource(chunks[i].data))
                                 }
                         }
                 }
         })
 }
 
 func prepIsolate(c context.Context, isolateURL string, desc *dm.Quest_Desc, prev *dm.JsonResult, params *sv1.Parameters) (*swarm.SwarmingRpcsFilesRef, error) {
         prevData := []byte("{}")
         if prev != nil {
                 prevData = []byte(prev.Object)
         }
         prevFile := mkFile(prevData)
         descData, descFile := mkMsgFile(desc)
         isoData, isoFile := mkIsolated(c, params, prevFile, descFile)
 
         err := pushIsolate(c, isolateURL, []isoChunk{
                 {data: prevData, file: prevFile},
                 {data: descData, file: descFile},
                 {data: isoData, file: isoFile, isIso: true},
         })
         if err != nil {
-                err = errors.Annotate(err).Reason("pushing new Isolated").Err()
+                err = errors.Annotate(err, "pushing new Isolated").Err()
                 return nil, err
         }
 
         return &swarm.SwarmingRpcsFilesRef{
                 Isolated:       string(isoFile.Digest),
                 Isolatedserver: isolateURL,
                 Namespace:      isolatedclient.DefaultNamespace,
         }, nil
 }