Make LazyMultiError constructed via function

service/memcache/memcache.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package memcache
 
 import (
         "github.com/luci/luci-go/common/errors"
         "golang.org/x/net/context"
 )
@@ skipping 15 matching lines @@
 }
 
 func (m *memcacheImpl) Delete(key string) error {
         return errors.SingleError(m.DeleteMulti([]string{key}))
 }
 
 func (m *memcacheImpl) CompareAndSwap(item Item) error {
         return errors.SingleError(m.CompareAndSwapMulti([]Item{item}))
 }
 
-func filterItems(lme *errors.LazyMultiError, items []Item, nilErr error) ([]Item, []int) {
+func filterItems(lme errors.LazyMultiError, items []Item, nilErr error) ([]Item, []int) {
         idxMap := make([]int, 0, len(items))
         retItems := make([]Item, 0, len(items))
         for i, itm := range items {
                 if itm != nil {
                         idxMap = append(idxMap, i)
                         retItems = append(retItems, itm)
                 } else {
                         lme.Assign(i, nilErr)
                 }
         }
         return retItems, idxMap
 }
 
 func multiCall(items []Item, nilErr error, inner func(items []Item, cb RawCB) error) error {
-        lme := errors.LazyMultiError{Size: len(items)}
-        realItems, idxMap := filterItems(&lme, items, nilErr)
+        lme := errors.NewLazyMultiError(len(items))
+        realItems, idxMap := filterItems(lme, items, nilErr)
         j := 0
         err := inner(realItems, func(err error) {
                 lme.Assign(idxMap[j], err)
                 j++
         })
         if err == nil {
                 err = lme.Get()
         }
         return err
 }
 
 func (m *memcacheImpl) AddMulti(items []Item) error {
         return multiCall(items, ErrNotStored, m.RawInterface.AddMulti)
 }
 
 func (m *memcacheImpl) SetMulti(items []Item) error {
         return multiCall(items, ErrNotStored, m.RawInterface.SetMulti)
 }
 
 func (m *memcacheImpl) CompareAndSwapMulti(items []Item) error {
         return multiCall(items, ErrNotStored, m.RawInterface.CompareAndSwapMulti)
 }
 
 func (m *memcacheImpl) DeleteMulti(keys []string) error {
-        lme := errors.LazyMultiError{Size: len(keys)}
+        lme := errors.NewLazyMultiError(len(keys))
         i := 0
         err := m.RawInterface.DeleteMulti(keys, func(err error) {
                 lme.Assign(i, err)
                 i++
         })
         if err == nil {
                 err = lme.Get()
         }
         return err
 }
 
 func (m *memcacheImpl) GetMulti(items []Item) error {
-        lme := errors.LazyMultiError{Size: len(items)}
-        realItems, idxMap := filterItems(&lme, items, ErrCacheMiss)
+        lme := errors.NewLazyMultiError(len(items))
+        realItems, idxMap := filterItems(lme, items, ErrCacheMiss)
         if len(realItems) == 0 {
                 return lme.Get()
         }
 
         keys := make([]string, len(realItems))
         for i, itm := range realItems {
                 keys[i] = itm.Key()
         }
 
         j := 0
@@ skipping 17 matching lines @@
 func (m *memcacheImpl) IncrementExisting(key string, delta int64) (newValue uint64, err error) {
         return m.RawInterface.Increment(key, delta, nil)
 }
 
 func (m *memcacheImpl) Raw() RawInterface { return m.RawInterface }
 
 // Get gets the current memcache implementation from the context.
 func Get(c context.Context) Interface {
         return &memcacheImpl{GetRaw(c)}
 }