Remove most error code from luci/gae

impl/prod/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 prod
 
 import (
         "time"
 
-        "github.com/luci/gae"
         mc "github.com/luci/gae/service/memcache"
+        "github.com/luci/luci-go/common/errors"
         "golang.org/x/net/context"
         "google.golang.org/appengine/memcache"
 )
 
 // useMC adds a gae.Memcache implementation to context, accessible
 // by gae.GetMC(c)
 func useMC(c context.Context) context.Context {
         return mc.SetFactory(c, func(ci context.Context) mc.Interface {
                 return mcImpl{ci}
         })
@@ skipping 81 matching lines @@
 }
 func (m mcImpl) Get(key string) (mc.Item, error) {
         return mcR2FErr(memcache.Get(m.Context, key))
 }
 func (m mcImpl) CompareAndSwap(item mc.Item) error {
         return memcache.CompareAndSwap(m.Context, mcF2R(item))
 }
 
 //////// MCMultiReadWriter
 func (m mcImpl) DeleteMulti(keys []string) error {
-        return gae.FixError(memcache.DeleteMulti(m.Context, keys))
+        return errors.Fix(memcache.DeleteMulti(m.Context, keys))
 }
 func (m mcImpl) AddMulti(items []mc.Item) error {
-        return gae.FixError(memcache.AddMulti(m.Context, mcMF2R(items)))
+        return errors.Fix(memcache.AddMulti(m.Context, mcMF2R(items)))
 }
 func (m mcImpl) SetMulti(items []mc.Item) error {
-        return gae.FixError(memcache.SetMulti(m.Context, mcMF2R(items)))
+        return errors.Fix(memcache.SetMulti(m.Context, mcMF2R(items)))
 }
 func (m mcImpl) GetMulti(keys []string) (map[string]mc.Item, error) {
         realItems, err := memcache.GetMulti(m.Context, keys)
         if err != nil {
-                return nil, gae.FixError(err)
+                return nil, errors.Fix(err)
         }
         items := make(map[string]mc.Item, len(realItems))
         for k, itm := range realItems {
                 items[k] = mcItem{itm}
         }
         return items, err
 }
 func (m mcImpl) CompareAndSwapMulti(items []mc.Item) error {
-        return gae.FixError(memcache.CompareAndSwapMulti(m.Context, mcMF2R(items)))
+        return errors.Fix(memcache.CompareAndSwapMulti(m.Context, mcMF2R(items)))
 }
 
 //////// MCIncrementer
 func (m mcImpl) Increment(key string, delta int64, initialValue uint64) (uint64, error) {
         return memcache.Increment(m.Context, key, delta, initialValue)
 }
 func (m mcImpl) IncrementExisting(key string, delta int64) (uint64, error) {
         return memcache.IncrementExisting(m.Context, key, delta)
 }
 
 //////// MCFlusher
 func (m mcImpl) Flush() error {
         return memcache.Flush(m.Context)
 }
 
 //////// MCStatter
 func (m mcImpl) Stats() (*mc.Statistics, error) {
         stats, err := memcache.Stats(m.Context)
         if err != nil {
                 return nil, err
         }
         return (*mc.Statistics)(stats), nil
 }