Add "MkKeyContext" KeyContext generation function.

impl/memory/datastore_data.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 (
         "bytes"
         "fmt"
         "strings"
@@ skipping 158 matching lines @@
 func (d *dataStoreData) namespaces() []string {
         d.rwlock.Lock()
         defer d.rwlock.Unlock()
 
         return namespaces(d.head)
 }
 
 /////////////////////////// indexes(dataStoreData) ////////////////////////////
 
 func groupMetaKey(key *ds.Key) []byte {
-        return keyBytes(ds.KeyContext{}.NewKey("__entity_group__", "", 1, key.Root()))
+        return keyBytes(ds.MkKeyContext("", "").NewKey("__entity_group__", "", 1, key.Root()))
 }
 
 func groupIDsKey(key *ds.Key) []byte {
-        return keyBytes(ds.KeyContext{}.NewKey("__entity_group_ids__", "", 1, key.Root()))
+        return keyBytes(ds.MkKeyContext("", "").NewKey("__entity_group_ids__", "", 1, key.Root()))
 }
 
 func rootIDsKey(kind string) []byte {
-        return keyBytes(ds.KeyContext{}.NewKey("__entity_root_ids__", kind, 0, nil))
+        return keyBytes(ds.MkKeyContext("", "").NewKey("__entity_root_ids__", kind, 0, nil))
 }
 
 func curVersion(ents memCollection, key []byte) int64 {
         if ents != nil {
                 if v := ents.Get(key); v != nil {
                         pm, err := rpm(v)
                         memoryCorruption(err)
 
                         pl := pm.Slice("__version__")
                         if len(pl) > 0 && pl[0].Type() == ds.PTInt {
@@ skipping 207 matching lines @@
 }
 
 func (d *dataStoreData) canApplyTxn(obj memContextObj) bool {
         // TODO(riannucci): implement with Flush/FlushRevert for persistance.
 
         txn := obj.(*txnDataStoreData)
         for rk, muts := range txn.muts {
                 if len(muts) == 0 { // read-only
                         continue
                 }
-                prop, err := serialize.ReadProperty(bytes.NewBufferString(rk), serialize.WithContext, ds.KeyContext{})
+                prop, err := serialize.ReadProperty(bytes.NewBufferString(rk), serialize.WithContext, ds.MkKeyContext("", ""))
                 memoryCorruption(err)
 
                 k := prop.Value().(*ds.Key)
 
                 entKey := "ents:" + k.Namespace()
                 mkey := groupMetaKey(k)
                 entsHead := d.head.GetCollection(entKey)
                 entsSnap := txn.snap.GetCollection(entKey)
                 vHead := curVersion(entsHead, mkey)
                 vSnap := curVersion(entsSnap, mkey)
@@ skipping 170 matching lines @@
         }
         return nil
 }
 
 func keyBytes(key *ds.Key) []byte {
         return serialize.ToBytes(ds.MkProperty(key))
 }
 
 func rpm(data []byte) (ds.PropertyMap, error) {
         return serialize.ReadPropertyMap(bytes.NewBuffer(data),
-                serialize.WithContext, ds.KeyContext{})
+                serialize.WithContext, ds.MkKeyContext("", ""))
 }
 
 func namespaces(store memStore) []string {
         var namespaces []string
         for _, c := range store.GetCollectionNames() {
                 ns, has := trimPrefix(c, "ents:")
                 if !has {
                         if len(namespaces) > 0 {
                                 break
                         }
                         continue
                 }
                 namespaces = append(namespaces, ns)
         }
         return namespaces
 }
 
 func trimPrefix(v, p string) (string, bool) {
         if strings.HasPrefix(v, p) {
                 return v[len(p):], true
         }
         return v, false
 }