Add context-aware "time" library wrapper.

go/src/infra/gae/libs/wrapper/memory/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 (
         "errors"
         "infra/gae/libs/wrapper"
         goon_internal "infra/gae/libs/wrapper/memory/internal/goon"
-        "math/rand"
         "sync"
         "sync/atomic"
 
         "github.com/mjibson/goon"
 
         "appengine/datastore"
         pb "appengine_internal/datastore"
+        "golang.org/x/net/context"
 )
 
 ////////////////////////////////// knrKeeper ///////////////////////////////////
 
 type knrKeeper struct {
         knrLock sync.Mutex
         knrFunc goon.KindNameResolver
 }
 
 var _ = wrapper.DSKindSetter((*knrKeeper)(nil))
@@ skipping 271 matching lines @@
                 if err != nil {
                         panic(err)
                 }
                 if vHead != vSnap {
                         return false
                 }
         }
         return true
 }
 
-func (d *dataStoreData) applyTxn(r *rand.Rand, obj memContextObj) {
+func (d *dataStoreData) applyTxn(c context.Context, obj memContextObj) {
         txn := obj.(*txnDataStoreData)
         for _, muts := range txn.muts {
                 if len(muts) == 0 { // read-only
                         continue
                 }
                 for _, m := range muts {
                         err := error(nil)
                         if m.data == nil {
                                 err = d.del(m.key.Namespace(), m.key)
                         } else {
@@ skipping 56 matching lines @@
 
 const xgEGLimit = 25
 
 func (*txnDataStoreData) canApplyTxn(memContextObj) bool { return false }
 func (td *txnDataStoreData) endTxn() {
         if atomic.LoadInt32(&td.closed) == 1 {
                 panic("cannot end transaction twice")
         }
         atomic.StoreInt32(&td.closed, 1)
 }
-func (*txnDataStoreData) applyTxn(*rand.Rand, memContextObj) {
+func (*txnDataStoreData) applyTxn(context.Context, memContextObj) {
         panic("txnDataStoreData cannot apply transactions")
 }
 func (*txnDataStoreData) mkTxn(*datastore.TransactionOptions) (memContextObj, error) {
         return nil, errors.New("datastore: nested transactions are not supported")
 }
 
 func (td *txnDataStoreData) IsBroken() error {
         // Slightly different from the SDK... datastore and taskqueue each implement
         // this here, where in the SDK only datastore.transaction.Call does.
         if atomic.LoadInt32(&td.closed) == 1 {
@@ skipping 70 matching lines @@
                 return td.snap.GetCollection("ents:" + ns), nil
         })
 }
 
 func (td *txnDataStoreData) del(ns string, key *datastore.Key) error {
         if !keyValid(ns, key, userKeyOnly) {
                 return datastore.ErrInvalidKey
         }
         return td.writeMutation(false, key, nil)
 }