Refactor serialization helpers from impl/memory -> service/datastore/serialize

impl/memory/gkvlite_iter.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"
         "sync"
 
+        "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/gkvlite"
 )
 
 type iterDefinition struct {
         // The collection to iterate over
         c *memCollection
 
         // The prefix to always assert for every row. A nil prefix matches every row.
         prefix []byte
 
@@ skipping 36 matching lines @@
         for {
                 stop := false
                 restart := false
 
                 for idx, it := range ts {
                         if skip >= 0 && skip == idx {
                                 continue
                         }
                         def := defs[idx]
 
-                        it.next(bjoin(def.prefix, suffix), func(itm *gkvlite.Item) {
+                        it.next(serialize.Join(def.prefix, suffix), func(itm *gkvlite.Item) {
                                 if itm == nil {
                                         // we hit the end of an iterator, we're now done with the whole
                                         // query.
                                         stop = true
                                         return
                                 }
 
                                 sfxRO := itm.Key[prefixLens[idx]:]
 
                                 if bytes.Compare(sfxRO, suffix) > 0 {
@@ skipping 42 matching lines @@
         cmdChan := make(chan *cmd)
         ret := &iterator{
                 ch: cmdChan,
         }
 
         prefix := def.prefix
         collection := def.c
 
         // convert the suffixes from the iterDefinition into full rows for the
         // underlying storage.
-        start := bjoin(prefix, def.start)
+        start := serialize.Join(prefix, def.start)
 
         end := []byte(nil)
         if def.end != nil {
-                end = bjoin(prefix, def.end)
+                end = serialize.Join(prefix, def.end)
         }
 
         go func() {
                 c := (*cmd)(nil)
                 ensureCmd := func() bool {
                         if c == nil {
                                 c = <-cmdChan
                                 if c == nil { // stop()
                                         return false
                                 }
@@ skipping 60 matching lines @@
         t.ch <- &cmd{targ, func(i *gkvlite.Item) {
                 defer close(waiter)
 
                 if i == nil {
                         t.stop()
                 }
                 cb(i)
         }}
         <-waiter
 }