Roll infra/go/src/github.com/luci/luci-go/ to b85c6dd748361e8244122faac44b5beefcd2db37.

go/src/infra/gae/libs/wrapper/memory/key.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 (
         "bytes"
         "errors"
         "fmt"
 
         "github.com/golang/protobuf/proto"
-        "github.com/luci/luci-go/common/funnybase"
+        "github.com/luci/luci-go/common/cmpbin"
         "github.com/mjibson/goon"
 
         "appengine"
         "appengine/datastore"
         "appengine_internal"
         basepb "appengine_internal/base"
 )
 
 const keyNumToksReasonableLimit = 50
 
@@ skipping 83 matching lines @@
 func keyFromByteString(nso nsOption, d string, ns string) (*datastore.Key, error) {
         return readKey(bytes.NewBufferString(d), nso, ns)
 }
 
 func writeKey(buf *bytes.Buffer, nso nsOption, k *datastore.Key) {
         // namespace ++ #tokens ++ [tok.kind ++ tok.stringID ++ tok.intID?]*
         namespace, toks := keyToToks(k)
         if nso == withNS {
                 writeString(buf, namespace)
         }
-        funnybase.WriteUint(buf, uint64(len(toks)))
+        cmpbin.WriteUint(buf, uint64(len(toks)))
         for _, tok := range toks {
                 writeString(buf, tok.kind)
                 writeString(buf, tok.stringID)
                 if tok.stringID == "" {
-                        funnybase.WriteUint(buf, tok.intID)
+                        cmpbin.WriteUint(buf, tok.intID)
                 }
         }
 }
 
 func readKey(buf *bytes.Buffer, nso nsOption, ns string) (*datastore.Key, error) {
         namespace := ns
         if nso == withNS {
                 err := error(nil)
                 if namespace, err = readString(buf); err != nil {
                         return nil, err
                 }
         }
 
-        numToks, err := funnybase.ReadUint(buf)
+        numToks, _, err := cmpbin.ReadUint(buf)
         if err != nil {
                 return nil, err
         }
         if numToks > keyNumToksReasonableLimit {
                 return nil, fmt.Errorf("readKey: tried to decode huge key of length %d", numToks)
         }
 
         toks := make([]*keyTok, numToks)
         for i := uint64(0); i < numToks; i++ {
                 tok := &keyTok{}
                 if tok.kind, err = readString(buf); err != nil {
                         return nil, err
                 }
                 if tok.stringID, err = readString(buf); err != nil {
                         return nil, err
                 }
                 if tok.stringID == "" {
-                        if tok.intID, err = funnybase.ReadUint(buf); err != nil {
+                        if tok.intID, _, err = cmpbin.ReadUint(buf); err != nil {
                                 return nil, err
                         }
                         if tok.intID == 0 {
                                 return nil, errors.New("readKey: decoded key with empty stringID and empty intID")
                         }
                 }
                 toks[i] = tok
         }
 
         return toksToKey(namespace, toks), nil
@@ skipping 62 matching lines @@
 // keyCouldBeValid is like keyValid, but it allows for the possibility that the
 // last token of the key is Incomplete(). It returns true if the Key will become
 // valid once it recieves an automatically-assigned ID.
 func keyCouldBeValid(ns string, k *datastore.Key, opt keyValidOption) bool {
         // adds an id to k if it's incomplete.
         if k.Incomplete() {
                 k = newKey(ns, k.Kind(), "", 1, k.Parent())
         }
         return keyValid(ns, k, opt)
 }