Add context-aware "time" library wrapper.

go/src/infra/gae/libs/wrapper/memory/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 memory
 
 import (
         "infra/gae/libs/wrapper"
         "infra/gae/libs/wrapper/gae/commonErrors"
         "infra/gae/libs/wrapper/unsafe"
+        "infra/libs/clock"
         "sync"
         "time"
 
         "golang.org/x/net/context"
 
         "appengine/memcache"
 )
 
 type memcacheData struct {
         wrapper.BrokenFeatures
 
         lock  sync.Mutex
         items map[string]*unsafe.Item
         casID uint64
 }
 
 // memcacheImpl binds the current connection's memcache data to an
 // implementation of {wrapper.Memcache, wrapper.Testable}.
 type memcacheImpl struct {
         wrapper.Memcache
 
-        data    *memcacheData
-        timeNow func() time.Time
+        data *memcacheData
+        ctx  context.Context

[iannucci, 2015/06/03 17:37:19]

+1

 }
 
 var (
         _ = wrapper.Memcache((*memcacheImpl)(nil))
         _ = wrapper.Testable((*memcacheImpl)(nil))
 )
 
 // useMC adds a wrapper.Memcache implementation to context, accessible
 // by wrapper.GetMC(c)
 func useMC(c context.Context) context.Context {
@@ skipping 10 matching lines @@
                         mcd = &memcacheData{
                                 BrokenFeatures: wrapper.BrokenFeatures{
                                         DefaultError: commonErrors.ErrServerErrorMC},
                                 items: map[string]*unsafe.Item{}}
                         mcdMap[ns] = mcd
                 }
 
                 return &memcacheImpl{
                         wrapper.DummyMC(),
                         mcd,
-                        func() time.Time { return wrapper.GetTimeNow(ic) },
+                        ic,
                 }
         })
 }
 
 func (m *memcacheImpl) mkItemLocked(i *memcache.Item) *unsafe.Item {
         m.data.casID++
         var exp time.Duration
         if i.Expiration != 0 {
-                exp = time.Duration(m.timeNow().Add(i.Expiration).UnixNano())
+                exp = time.Duration(clock.Now(m.ctx).Add(i.Expiration).UnixNano())
         }
         newItem := unsafe.Item{
                 Key:        i.Key,
                 Value:      make([]byte, len(i.Value)),
                 Flags:      i.Flags,
                 Expiration: exp,
                 CasID:      m.data.casID,
         }
         copy(newItem.Value, i.Value)
         return &newItem
 }
 
 func copyBack(i *unsafe.Item) *memcache.Item {
         ret := &memcache.Item{
                 Key:   i.Key,
                 Value: make([]byte, len(i.Value)),
                 Flags: i.Flags,
         }
         copy(ret.Value, i.Value)
         unsafe.MCSetCasID(ret, i.CasID)
 
         return ret
 }
 
 func (m *memcacheImpl) retrieve(key string) (*unsafe.Item, bool) {
         ret, ok := m.data.items[key]
-        if ok && ret.Expiration != 0 && ret.Expiration < time.Duration(m.timeNow().UnixNano()) {
+        if ok && ret.Expiration != 0 && ret.Expiration < time.Duration(clock.Now(m.ctx).UnixNano()) {
                 ret = nil
                 ok = false
                 delete(m.data.items, key)
         }
         return ret, ok
 }
 
 func (m *memcacheImpl) BreakFeatures(err error, features ...string) {
         m.data.BreakFeatures(err, features...)
 }
@@ skipping 75 matching lines @@
 
         m.data.lock.Lock()
         defer m.data.lock.Unlock()
 
         if _, ok := m.retrieve(key); ok {
                 delete(m.data.items, key)
                 return nil
         }
         return memcache.ErrCacheMiss
 }