Make appengine connection explicitly owned by impl/prod.

impl/prod/datastore_key.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 (
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/errors"
         "golang.org/x/net/context"
@@ skipping 23 matching lines @@
         for ; k != nil; k = k.Parent() {
                 count--
                 toks[count].Kind = k.Kind()
                 toks[count].StringID = k.StringID()
                 toks[count].IntID = k.IntID()
         }
         return ds.NewKeyToks(aid, ns, toks)
 }
 
 // dsF2R (DS fake-to-real) converts a DSKey back to an SDK *Key.
-func dsF2R(ctx context.Context, k *ds.Key) (*datastore.Key, error) {
+func dsF2R(aeCtx context.Context, k *ds.Key) (*datastore.Key, error) {

[Vadim Sh., 2015/12/03 00:49:57]

how do you feel about adding a typedef for AE context to avoid accidental
misuse? e.g.

type aeContext context.Context

func dsF2R(e aeContext ...) { ... }

?

         if k == nil {
                 return nil, nil
         }
 
         // drop aid.
         _, ns, toks := k.Split()
         err := error(nil)
-        ctx, err = appengine.Namespace(ctx, ns)
+        aeCtx, err = appengine.Namespace(aeCtx, ns)
         if err != nil {
                 return nil, err
         }
 
-        ret := datastore.NewKey(ctx, toks[0].Kind, toks[0].StringID, toks[0].IntID, nil)
+        ret := datastore.NewKey(aeCtx, toks[0].Kind, toks[0].StringID, toks[0].IntID, nil)
         for _, t := range toks[1:] {
-                ret = datastore.NewKey(ctx, t.Kind, t.StringID, t.IntID, ret)
+                ret = datastore.NewKey(aeCtx, t.Kind, t.StringID, t.IntID, ret)
         }
 
         return ret, nil
 }
 
 // dsMF2R (DS multi-fake-to-fake) converts a slice of wrapped keys to SDK keys.
-func dsMF2R(ctx context.Context, ks []*ds.Key) ([]*datastore.Key, error) {
+func dsMF2R(aeCtx context.Context, ks []*ds.Key) ([]*datastore.Key, error) {
         lme := errors.NewLazyMultiError(len(ks))
         ret := make([]*datastore.Key, len(ks))
         err := error(nil)
         for i, k := range ks {
-                ret[i], err = dsF2R(ctx, k)
+                ret[i], err = dsF2R(aeCtx, k)
                 lme.Assign(i, err)
         }
         return ret, lme.Get()
 }