Fix 'impl/memory' context key.

impl/memory/context.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "errors"
         "strings"
         "sync"
@@ skipping 99 matching lines @@
 // context. If 'aid' contains a "~" character, it will be treated as the
 // fully-qualified App ID and the AppID will be the string following the "~".
 //
 // These can be retrieved with the gae.Get functions.
 //
 // The implementations are all backed by an in-memory implementation, and start
 // with an empty state.
 //
 // Using this more than once per context.Context will cause a panic.
 func UseWithAppID(c context.Context, aid string) context.Context {
-        if c.Value(memContextKey) != nil {
+        if c.Value(&memContextKey) != nil {
                 panic(errors.New("memory.Use: called twice on the same Context"))
         }
         c = memlogger.Use(c)
 
         fqAppID := aid
         if parts := strings.SplitN(fqAppID, "~", 2); len(parts) == 2 {
                 aid = parts[1]
         }
 
         memctx := newMemContext(fqAppID)
-        c = context.WithValue(c, memContextKey, memctx)
+        c = context.WithValue(c, &memContextKey, memctx)
         c = useGID(c, func(mod *globalInfoData) {
                 mod.appID = aid
                 mod.fqAppID = fqAppID
         })
         return useMod(useMail(useUser(useTQ(useRDS(useMC(useGI(c)))))))
 }
 
 func cur(c context.Context) (*memContext, bool) {
-        if txn := c.Value(currentTxnKey); txn != nil {
+        if txn := c.Value(&currentTxnKey); txn != nil {
                 // We are in a Transaction.
                 return txn.(*memContext), true
         }
-        return c.Value(memContextKey).(*memContext), false
+        return c.Value(&memContextKey).(*memContext), false
 }
 
-type memContextKeyType int
-
 var (
-        memContextKey memContextKeyType
-        currentTxnKey = 1
+        memContextKey = "gae:memory:context"
+        currentTxnKey = "gae:memory:currentTxn"
 )
 
 // weird stuff
 
 // RunInTransaction is here because it's really a service-wide transaction, not
 // just in the datastore. TaskQueue behaves differently in a transaction in
 // a couple ways, for example.
 //
 // It really should have been appengine.Context.RunInTransaction(func(tc...)),
 // but because it's not, this method is on dsImpl instead to mirror the official
@@ skipping 17 matching lines @@
 
                 txnMC := curMC.mkTxn(o)
 
                 defer func() {
                         txnMC.Lock()
                         defer txnMC.Unlock()
 
                         txnMC.endTxn()
                 }()
 
-                if err := f(context.WithValue(d, currentTxnKey, txnMC)); err != nil {
+                if err := f(context.WithValue(d, &currentTxnKey, txnMC)); err != nil {
                         return err
                 }
 
                 txnMC.Lock()
                 defer txnMC.Unlock()
 
                 if applyForReal && curMC.canApplyTxn(txnMC) {
                         curMC.applyTxn(d, txnMC)
                 } else {
                         return ds.ErrConcurrentTransaction
                 }
                 return nil
         }
 
         // From GAE docs for TransactionOptions: "If omitted, it defaults to 3."
         attempts := 3
         if o != nil && o.Attempts != 0 {
                 attempts = o.Attempts
         }
         for attempt := 0; attempt < attempts; attempt++ {
                 if err := loopBody(attempt >= d.data.txnFakeRetry); err != ds.ErrConcurrentTransaction {
                         return err
                 }
         }
         return ds.ErrConcurrentTransaction
 }