Update cloud implementation w/ new datastore API

impl/cloud/datastore.go

 // Copyright 2016 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 cloud
 
 import (
         "fmt"
         "reflect"
         "strings"
         "time"
 
         "github.com/luci/luci-go/common/errors"
 
         ds "github.com/luci/gae/service/datastore"
-        "github.com/luci/gae/service/info"
 
         "cloud.google.com/go/datastore"
+        "google.golang.org/api/iterator"
 
         "golang.org/x/net/context"
 )
 
 type cloudDatastore struct {
         client *datastore.Client
 }
 
 func (cds *cloudDatastore) use(c context.Context) context.Context {
         return ds.SetRawFactory(c, func(ic context.Context) ds.RawInterface {
-                if ns := info.GetNamespace(ic); ns != "" {
-                        ic = datastore.WithNamespace(ic, ns)
-                }
-
                 return &boundDatastore{
                         Context:        ic,
                         cloudDatastore: cds,
                         transaction:    datastoreTransaction(ic),
                         kc:             ds.GetKeyContext(ic),
                 }
         })
 }
 
 // boundDatastore is a bound instance of the cloudDatastore installed in the
@@ skipping 61 matching lines @@
                 return it.Cursor()
         }
 
         for {
                 var npls *nativePropertyLoadSaver
                 if !q.KeysOnly() {
                         npls = bds.mkNPLS(nil)
                 }
                 nativeKey, err := it.Next(npls)
                 if err != nil {
-                        if err == datastore.Done {
+                        if err == iterator.Done {
                                 return nil
                         }
                         return normalizeError(err)
                 }
 
                 var pmap ds.PropertyMap
                 if npls != nil {
                         pmap = npls.pmap
                 }
                 if err := cb(bds.nativeKeysToGAE(nativeKey)[0], pmap, cursorFn); err != nil {
@@ skipping 133 matching lines @@
 
 func (bds *boundDatastore) CurrentTransaction() ds.Transaction { return bds.transaction }
 
 func (bds *boundDatastore) GetTestable() ds.Testable { return nil }
 
 func (bds *boundDatastore) prepareNativeQuery(fq *ds.FinalizedQuery) *datastore.Query {
         nq := datastore.NewQuery(fq.Kind())
         if bds.transaction != nil {
                 nq = nq.Transaction(bds.transaction)
         }
+        if ns := bds.kc.Namespace; ns != "" {
+                nq = nq.Namespace(ns)
+        }
 
         // nativeFilter translates a filter field. If the translation fails, we'll
         // pass the result through to the underlying datastore and allow it to
         // reject it.
         nativeFilter := func(prop ds.Property) interface{} {
                 if np, err := bds.gaePropertyToNative("", prop); err == nil {
                         return np.Value
                 }
                 return prop.Value()
         }
@@ skipping 173 matching lines @@
         return
 }
 
 func (bds *boundDatastore) gaeKeysToNative(keys ...*ds.Key) []*datastore.Key {
         nativeKeys := make([]*datastore.Key, len(keys))
         for i, key := range keys {
                 _, _, toks := key.Split()
 
                 var nativeKey *datastore.Key
                 for _, tok := range toks {
-                        nativeKey = datastore.NewKey(bds, tok.Kind, tok.StringID, tok.IntID, nativeKey)
+                        nativeKey = &datastore.Key{
+                                Kind:      tok.Kind,
+                                ID:        tok.IntID,
+                                Name:      tok.StringID,
+                                Parent:    nativeKey,
+                                Namespace: key.Namespace(),
+                        }
                 }
                 nativeKeys[i] = nativeKey
         }
         return nativeKeys
 }
 
 func (bds *boundDatastore) nativeKeysToGAE(nativeKeys ...*datastore.Key) []*ds.Key {
         keys := make([]*ds.Key, len(nativeKeys))
         toks := make([]ds.KeyTok, 1)
 
         kc := bds.kc
         for i, nativeKey := range nativeKeys {
                 toks = toks[:0]
                 cur := nativeKey
                 for {
-                        toks = append(toks, ds.KeyTok{Kind: cur.Kind(), IntID: cur.ID(), StringID: cur.Name()})
-                        cur = cur.Parent()
+                        toks = append(toks, ds.KeyTok{Kind: cur.Kind, IntID: cur.ID, StringID: cur.Name})
+                        cur = cur.Parent
                         if cur == nil {
                                 break
                         }
                 }
 
                 // Reverse "toks" so we have ancestor-to-child lineage.
                 for i := 0; i < len(toks)/2; i++ {
                         ri := len(toks) - i - 1
                         toks[i], toks[ri] = toks[ri], toks[i]
                 }
-                kc.Namespace = nativeKey.Namespace()
+                kc.Namespace = nativeKey.Namespace
                 keys[i] = kc.NewKeyToks(toks)
         }
         return keys
 }
 
 // nativePropertyLoadSaver is a ds.PropertyMap which implements
 // datastore.PropertyLoadSaver.
 //
 // It naturally converts between native and GAE properties and values.
 type nativePropertyLoadSaver struct {
@@ skipping 73 matching lines @@
         case datastore.ErrNoSuchEntity:
                 return ds.ErrNoSuchEntity
         case datastore.ErrConcurrentTransaction:
                 return ds.ErrConcurrentTransaction
         case datastore.ErrInvalidKey:
                 return ds.ErrInvalidKey
         default:
                 return err
         }
 }