Simplify memory package interface.

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"
@@ skipping 134 matching lines @@
                         return nil, nil, err
                 }
                 key = newKey(key.Namespace(), key.Kind(), "", id, key.Parent())
         }
 
         return ents, key, nil
 }
 
 func putPrelim(ns string, knr goon.KindNameResolver, src interface{}) (*datastore.Key, *propertyList, error) {
         key := newKeyObj(ns, knr, src)
-        if !KeyCouldBeValid(ns, key, UserKeyOnly) {
+        if !keyCouldBeValid(ns, key, userKeyOnly) {
                 // TODO(riannucci): different error for Put-ing to reserved Keys?
                 return nil, nil, datastore.ErrInvalidKey
         }
 
         data, err := toPL(src)
         return key, data, err
 }
 
 func (d *dataStoreData) put(ns string, src interface{}) (*datastore.Key, error) {
         key, plData, err := putPrelim(ns, d.KindNameResolver(), src)
@@ skipping 23 matching lines @@
                 return nil, err
         }
 
         ents.Set(keyBytes(noNS, key), dataBytes)
 
         return key, nil
 }
 
 func getInner(ns string, knr goon.KindNameResolver, dst interface{}, getColl func(*datastore.Key) (*memCollection, error)) error {
         key := newKeyObj(ns, knr, dst)
-        if !KeyValid(ns, key, AllowSpecialKeys) {
+        if !keyValid(ns, key, allowSpecialKeys) {
                 return datastore.ErrInvalidKey
         }
 
         ents, err := getColl(key)
         if err != nil {
                 return err
         }
         if ents == nil {
                 return datastore.ErrNoSuchEntity
         }
@@ skipping 12 matching lines @@
         return getInner(ns, d.KindNameResolver(), dst, func(*datastore.Key) (*memCollection, error) {
                 d.rwlock.RLock()
                 s := d.store.Snapshot()
                 d.rwlock.RUnlock()
 
                 return s.GetCollection("ents:" + ns), nil
         })
 }
 
 func (d *dataStoreData) del(ns string, key *datastore.Key) error {
-        if !KeyValid(ns, key, UserKeyOnly) {
+        if !keyValid(ns, key, userKeyOnly) {
                 return datastore.ErrInvalidKey
         }
 
         keyBuf := keyBytes(noNS, key)
 
         d.rwlock.Lock()
         defer d.rwlock.Unlock()
 
         ents := d.store.GetCollection("ents:" + ns)
         if ents == nil {
@@ skipping 194 matching lines @@
 func (td *txnDataStoreData) get(ns string, dst interface{}) error {
         return getInner(ns, td.KindNameResolver(), dst, func(key *datastore.Key) (*memCollection, error) {
                 if err := td.writeMutation(true, key, nil); err != nil {
                         return nil, err
                 }
                 return td.snap.GetCollection("ents:" + ns), nil
         })
 }
 
 func (td *txnDataStoreData) del(ns string, key *datastore.Key) error {
-        if !KeyValid(ns, key, UserKeyOnly) {
+        if !keyValid(ns, key, userKeyOnly) {
                 return datastore.ErrInvalidKey
         }
         return td.writeMutation(false, key, nil)
 }