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

go/src/infra/gae/libs/wrapper/memory/plist.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"
         "fmt"
         "reflect"
         "sort"
         "time"
 
         "appengine"
         "appengine/datastore"
 
         "github.com/luci/gkvlite"
-        "github.com/luci/luci-go/common/funnybase"
+        "github.com/luci/luci-go/common/cmpbin"
 )
 
 type typData struct {
         noIndex bool
         typ     propValType
         data    interface{}
 }
 
 func newTypData(noIndex bool, v interface{}) (ret *typData, err error) {
         typ := pvUNKNOWN
@@ skipping 34 matching lines @@
 func (td *typData) WriteBinary(buf *bytes.Buffer, nso nsOption) error {
         typb := byte(td.typ)
         if td.noIndex {
                 typb |= 0x80
         }
         buf.WriteByte(typb)
         switch td.typ {
         case pvNull, pvBoolFalse, pvBoolTrue:
                 return nil
         case pvInt:
-                funnybase.Write(buf, td.data.(int64))
+                cmpbin.WriteInt(buf, td.data.(int64))
         case pvFloat:
                 writeFloat64(buf, td.data.(float64))
         case pvStr:
                 writeString(buf, td.data.(string))
         case pvBytes:
                 if td.noIndex {
                         writeBytes(buf, td.data.([]byte))
                 } else {
                         writeBytes(buf, td.data.(datastore.ByteString))
                 }
@@ skipping 19 matching lines @@
         td.noIndex = (typb & 0x80) != 0 // highbit means noindex
         td.typ = propValType(typb & 0x7f)
         switch td.typ {
         case pvNull:
                 td.data = nil
         case pvBoolTrue:
                 td.data = true
         case pvBoolFalse:
                 td.data = false
         case pvInt:
-                td.data, err = funnybase.Read(buf)
+                td.data, _, err = cmpbin.ReadInt(buf)
         case pvFloat:
                 td.data, err = readFloat64(buf)
         case pvStr:
                 td.data, err = readString(buf)
         case pvBytes:
                 b := []byte(nil)
                 if b, err = readBytes(buf); err != nil {
                         return err
                 }
                 if td.noIndex {
@@ skipping 380 matching lines @@
 
 func (pl *propertyList) MarshalBinary() ([]byte, error) {
         cols, err := pl.collate()
         if err != nil || len(cols) == 0 {
                 return nil, err
         }
 
         pieces := make([][]byte, 0, len(*pl)*2+1)
         for _, pv := range cols {
                 // TODO(riannucci): estimate buffer size better.
-                buf := bytes.NewBuffer(make([]byte, 0, funnybase.MaxFunnyBaseLen64+len(pv.name)))
+                buf := bytes.NewBuffer(make([]byte, 0, cmpbin.MaxIntLen64+len(pv.name)))
                 writeString(buf, pv.name)
                 err := pv.WriteBinary(buf)
                 if err != nil {
                         return nil, err
                 }
                 pieces = append(pieces, buf.Bytes())
         }
         return bytes.Join(pieces, nil), nil
 }
 
@@ skipping 77 matching lines @@
         // These two are problematic, because they force us to bind to the appengine
         // SDK code. If we can drop support for these and turn them into hard errors,
         // that could let us decouple from the various appengine SDKs. Maybe.
         pvKey     // TODO(riannucci): remove support for this  (use a string)
         pvBlobKey // TODO(riannucci): remove support for this  (use a string)
 
         pvUNKNOWN
 )
 
 func (p *pvals) ReadBinary(buf *bytes.Buffer) error {
-        n, err := funnybase.ReadUint(buf)
+        n, _, err := cmpbin.ReadUint(buf)
         if err != nil {
                 return err
         }
 
         p.vals = make([]*typData, n)
         for i := range p.vals {
                 p.vals[i] = &typData{}
                 err := p.vals[i].ReadBinary(buf, withNS, "")
                 if err != nil {
                         return err
                 }
         }
 
         return nil
 }
 
 func (p *pvals) WriteBinary(buf *bytes.Buffer) error {
-        funnybase.WriteUint(buf, uint64(len(p.vals)))
+        cmpbin.WriteUint(buf, uint64(len(p.vals)))
         for _, v := range p.vals {
                 if err := v.WriteBinary(buf, withNS); err != nil {
                         return err
                 }
         }
         return nil
 }