Make appengine connection explicitly owned by impl/prod.

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"
 
         mc "github.com/luci/gae/service/memcache"
         "golang.org/x/net/context"
         "google.golang.org/appengine"
         "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.SetRawFactory(c, func(ci context.Context) mc.RawInterface {
-                return mcImpl{ci}
+                return mcImpl{AEContext(ci)}
         })
 }
 
-type mcImpl struct{ context.Context }
+type mcImpl struct {
+        aeCtx context.Context
+}
 
 type mcItem struct {
         i *memcache.Item
 }
 
 var _ mc.Item = mcItem{}
 
 func (i mcItem) Key() string               { return i.i.Key }
 func (i mcItem) Value() []byte             { return i.i.Value }
 func (i mcItem) Flags() uint32             { return i.i.Flags }
@@ skipping 65 matching lines @@
         if me, ok := err.(appengine.MultiError); ok {
                 for _, err := range me {
                         cb(err)
                 }
                 err = nil
         }
         return err
 }
 
 func (m mcImpl) DeleteMulti(keys []string, cb mc.RawCB) error {
-        return doCB(memcache.DeleteMulti(m.Context, keys), cb)
+        return doCB(memcache.DeleteMulti(m.aeCtx, keys), cb)
 }
 
 func (m mcImpl) AddMulti(items []mc.Item, cb mc.RawCB) error {
-        return doCB(memcache.AddMulti(m.Context, mcMF2R(items)), cb)
+        return doCB(memcache.AddMulti(m.aeCtx, mcMF2R(items)), cb)
 }
 
 func (m mcImpl) SetMulti(items []mc.Item, cb mc.RawCB) error {
-        return doCB(memcache.SetMulti(m.Context, mcMF2R(items)), cb)
+        return doCB(memcache.SetMulti(m.aeCtx, mcMF2R(items)), cb)
 }
 
 func (m mcImpl) GetMulti(keys []string, cb mc.RawItemCB) error {
-        realItems, err := memcache.GetMulti(m.Context, keys)
+        realItems, err := memcache.GetMulti(m.aeCtx, keys)
         if err != nil {
                 return err
         }
         for _, k := range keys {
                 itm := realItems[k]
                 if itm == nil {
                         cb(nil, memcache.ErrCacheMiss)
                 } else {
                         cb(mcItem{itm}, nil)
                 }
         }
         return nil
 }
 
 func (m mcImpl) CompareAndSwapMulti(items []mc.Item, cb mc.RawCB) error {
-        return doCB(memcache.CompareAndSwapMulti(m.Context, mcMF2R(items)), cb)
+        return doCB(memcache.CompareAndSwapMulti(m.aeCtx, mcMF2R(items)), cb)
 }
 
 func (m mcImpl) Increment(key string, delta int64, initialValue *uint64) (uint64, error) {
         if initialValue == nil {
-                return memcache.IncrementExisting(m.Context, key, delta)
+                return memcache.IncrementExisting(m.aeCtx, key, delta)
         }
-        return memcache.Increment(m.Context, key, delta, *initialValue)
+        return memcache.Increment(m.aeCtx, key, delta, *initialValue)
 }
 
 func (m mcImpl) Flush() error {
-        return memcache.Flush(m.Context)
+        return memcache.Flush(m.aeCtx)
 }
 
 func (m mcImpl) Stats() (*mc.Statistics, error) {
-        stats, err := memcache.Stats(m.Context)
+        stats, err := memcache.Stats(m.aeCtx)
         if err != nil {
                 return nil, err
         }
         return (*mc.Statistics)(stats), nil
 }