[errors] Greatly simplify common/errors package.

luci_config/server/cfgclient/backend/caching/codec.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 caching
 
 import (
         "bytes"
         "compress/zlib"
         "crypto/sha256"
         "encoding/binary"
         "encoding/json"
         "strings"
 
         "github.com/luci/luci-go/common/errors"
 )
 
 // Encode is a convenience method for generating a ZLIB-compressed JSON-encoded
 // object.
 func Encode(v interface{}) ([]byte, error) {
         var buf bytes.Buffer
         zw := zlib.NewWriter(&buf)
         enc := json.NewEncoder(zw)
 
         if err := enc.Encode(v); err != nil {
                 zw.Close()
-                return nil, errors.Annotate(err).Reason("failed to JSON-encode").Err()
+                return nil, errors.Annotate(err, "failed to JSON-encode").Err()
         }
         if err := zw.Close(); err != nil {
-                return nil, errors.Annotate(err).Reason("failed to Close zlib Writer").Err()
+                return nil, errors.Annotate(err, "failed to Close zlib Writer").Err()
         }
         return buf.Bytes(), nil
 }
 
 // Decode is a convenience method for decoding a ZLIB-compressed JSON-encoded
 // object encoded by Encode.
 func Decode(d []byte, v interface{}) error {
         zr, err := zlib.NewReader(bytes.NewReader(d))
         if err != nil {
-                return errors.Annotate(err).Reason("failed to create zlib Reader").Err()
+                return errors.Annotate(err, "failed to create zlib Reader").Err()
         }
         defer zr.Close()
 
         if err := json.NewDecoder(zr).Decode(v); err != nil {
-                return errors.Annotate(err).Reason("failed to JSON-decode").Err()
+                return errors.Annotate(err, "failed to JSON-decode").Err()
         }
         return nil
 }
 
 // HashParams is a convenience method for hashing a series of strings into a
 // unique hash key for that series.
 //
 // The output is fixed-size sha256.Size (32) bytes.
 func HashParams(params ...string) []byte {
         size := 0
@@ skipping 20 matching lines @@
                         _, _ = buf.Write(bytes.Replace([]byte(params[i]), []byte{0x00}, []byte{0x00, 0x00}, -1))
                 } else {
                         _, _ = buf.WriteString(s)
                 }
                 buf.WriteByte(0x00)
         }
 
         hash := sha256.Sum256(buf.Bytes())
         return hash[:]
 }