Remove most error code from luci/gae

impl/memory/raw_datastore_data.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 memory
 
 import (
         "bytes"
-        "errors"
         "fmt"
         "sync"
         "sync/atomic"
 
-        "github.com/luci/gae"
         rds "github.com/luci/gae/service/rawdatastore"
+        "github.com/luci/luci-go/common/errors"
         "golang.org/x/net/context"
 )
 
 //////////////////////////////// dataStoreData /////////////////////////////////
 
 type dataStoreData struct {
         rwlock sync.RWMutex
         // See README.md for store schema.
         store *memStore
         snap  *memStore
@@ skipping 80 matching lines @@
         }
 
         return ents, key
 }
 
 func (d *dataStoreData) put(ns string, key rds.Key, pls rds.PropertyLoadSaver) (rds.Key, error) {
         keys, errs := d.putMulti(ns, []rds.Key{key}, []rds.PropertyLoadSaver{pls})
         if errs == nil {
                 return keys[0], nil
         }
-        return nil, gae.SingleError(errs)
+        return nil, errors.SingleError(errs)
 }
 
 func (d *dataStoreData) putMulti(ns string, keys []rds.Key, plss []rds.PropertyLoadSaver) ([]rds.Key, error) {
         pmaps, err := putMultiPrelim(ns, keys, plss)
         if err != nil {
                 return nil, err
         }
         return d.putMultiInner(keys, pmaps)
 }
 
 func putMultiPrelim(ns string, keys []rds.Key, plss []rds.PropertyLoadSaver) ([]rds.PropertyMap, error) {
         err := multiValid(keys, plss, ns, true, false)
         if err != nil {
                 return nil, err
         }
         pmaps := make([]rds.PropertyMap, len(keys))
-        lme := gae.LazyMultiError{Size: len(keys)}
+        lme := errors.LazyMultiError{Size: len(keys)}
         for i, pls := range plss {
                 pm, err := pls.Save(false)
                 lme.Assign(i, err)
                 pmaps[i] = pm
         }
         return pmaps, lme.Get()
 }
 
 func (d *dataStoreData) putMultiInner(keys []rds.Key, data []rds.PropertyMap) ([]rds.Key, error) {
         retKeys := make([]rds.Key, len(keys))
-        lme := gae.LazyMultiError{Size: len(keys)}
+        lme := errors.LazyMultiError{Size: len(keys)}
         for i, k := range keys {
                 buf := &bytes.Buffer{}
                 data[i].Write(buf, rds.WithoutContext)
                 dataBytes := buf.Bytes()
 
                 rKey, err := func() (ret rds.Key, err error) {
                         d.rwlock.Lock()
                         defer d.rwlock.Unlock()
 
                         ents, ret := d.entsKeyLocked(k)
@@ skipping 14 matching lines @@
                 retKeys[i] = rKey
         }
         return retKeys, lme.Get()
 }
 
 func getMultiInner(ns string, keys []rds.Key, plss []rds.PropertyLoadSaver, getColl func() (*memCollection, error)) error {
         if err := multiValid(keys, plss, ns, false, true); err != nil {
                 return err
         }
 
-        lme := gae.LazyMultiError{Size: len(keys)}
+        lme := errors.LazyMultiError{Size: len(keys)}
 
         ents, err := getColl()
         if err != nil {
                 return err
         }
         if ents == nil {
                 for i := range keys {
                         lme.Assign(i, rds.ErrNoSuchEntity)
                 }
                 return lme.Get()
@@ skipping 11 matching lines @@
                         lme.Assign(i, err)
                         continue
                 }
 
                 lme.Assign(i, plss[i].Load(got))
         }
         return lme.Get()
 }
 
 func (d *dataStoreData) get(ns string, key rds.Key, pls rds.PropertyLoadSaver) error {
-        return gae.SingleError(d.getMulti(ns, []rds.Key{key}, []rds.PropertyLoadSaver{pls}))
+        return errors.SingleError(d.getMulti(ns, []rds.Key{key}, []rds.PropertyLoadSaver{pls}))
 }
 
 func (d *dataStoreData) getMulti(ns string, keys []rds.Key, plss []rds.PropertyLoadSaver) error {
         return getMultiInner(ns, keys, plss, func() (*memCollection, error) {
                 d.rwlock.RLock()
                 s := d.store.Snapshot()
                 d.rwlock.RUnlock()
 
                 return s.GetCollection("ents:" + ns), nil
         })
 }
 
 func (d *dataStoreData) del(ns string, key rds.Key) (err error) {
-        return gae.SingleError(d.delMulti(ns, []rds.Key{key}))
+        return errors.SingleError(d.delMulti(ns, []rds.Key{key}))
 }
 
 func (d *dataStoreData) delMulti(ns string, keys []rds.Key) error {
-        lme := gae.LazyMultiError{Size: len(keys)}
+        lme := errors.LazyMultiError{Size: len(keys)}
         toDel := make([][]byte, 0, len(keys))
         for i, k := range keys {
                 if !rds.KeyValid(k, ns, false) {
                         lme.Assign(i, rds.ErrInvalidKey)
                         continue
                 }
                 toDel = append(toDel, keyBytes(rds.WithoutContext, k))
         }
         err := lme.Get()
         if err != nil {
@@ skipping 171 matching lines @@
         }
 
         return nil
 }
 
 func (td *txnDataStoreData) put(ns string, key rds.Key, pls rds.PropertyLoadSaver) (rds.Key, error) {
         keys, errs := td.putMulti(ns, []rds.Key{key}, []rds.PropertyLoadSaver{pls})
         if errs == nil {
                 return keys[0], nil
         }
-        return nil, gae.SingleError(errs)
+        return nil, errors.SingleError(errs)
 }
 
 func (td *txnDataStoreData) putMulti(ns string, keys []rds.Key, plss []rds.PropertyLoadSaver) ([]rds.Key, error) {
         pmaps, err := putMultiPrelim(ns, keys, plss)
         if err != nil {
                 return nil, err
         }
 
         retKeys := make([]rds.Key, len(keys))
-        lme := gae.LazyMultiError{Size: len(keys)}
+        lme := errors.LazyMultiError{Size: len(keys)}
         for i, k := range keys {
                 func() {
                         td.parent.Lock()
                         defer td.parent.Unlock()
                         _, k = td.parent.entsKeyLocked(k)
                 }()
                 lme.Assign(i, td.writeMutation(false, k, pmaps[i]))
                 retKeys[i] = k
         }
 
         return retKeys, lme.Get()
 }
 
 func (td *txnDataStoreData) get(ns string, key rds.Key, pls rds.PropertyLoadSaver) error {
-        return gae.SingleError(td.getMulti(ns, []rds.Key{key}, []rds.PropertyLoadSaver{pls}))
+        return errors.SingleError(td.getMulti(ns, []rds.Key{key}, []rds.PropertyLoadSaver{pls}))
 }
 
 func (td *txnDataStoreData) getMulti(ns string, keys []rds.Key, plss []rds.PropertyLoadSaver) error {
         return getMultiInner(ns, keys, plss, func() (*memCollection, error) {
-                lme := gae.LazyMultiError{Size: len(keys)}
+                lme := errors.LazyMultiError{Size: len(keys)}
                 for i, k := range keys {
                         lme.Assign(i, td.writeMutation(true, k, nil))
                 }
                 return td.snap.GetCollection("ents:" + ns), lme.Get()
         })
 }
 
 func (td *txnDataStoreData) del(ns string, key rds.Key) error {
-        return gae.SingleError(td.delMulti(ns, []rds.Key{key}))
+        return errors.SingleError(td.delMulti(ns, []rds.Key{key}))
 }
 
 func (td *txnDataStoreData) delMulti(ns string, keys []rds.Key) error {
-        lme := gae.LazyMultiError{Size: len(keys)}
+        lme := errors.LazyMultiError{Size: len(keys)}
         for i, k := range keys {
                 if !rds.KeyValid(k, ns, false) {
                         lme.Assign(i, rds.ErrInvalidKey)
                 } else {
                         lme.Assign(i, td.writeMutation(false, k, nil))
                 }
         }
         return lme.Get()
 }
 
@@ skipping 28 matching lines @@
                         return rds.KeyValid(k, ns, allowSpecial)
                 }
         }
 
         if keys == nil || plss == nil {
                 return errors.New("gae: key or plss slices were nil")
         }
         if len(keys) != len(plss) {
                 return errors.New("gae: key and dst slices have different length")
         }
-        lme := gae.LazyMultiError{Size: len(keys)}
+        lme := errors.LazyMultiError{Size: len(keys)}
         for i, k := range keys {
                 if !vfn(k) {
                         lme.Assign(i, rds.ErrInvalidKey)
                 }
         }
         return lme.Get()
 }