filter/txnBuf: Use fully-qualified App ID.

filter/txnBuf/state.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 txnBuf
 
 import (
         "bytes"
         "sync"
 
@@ skipping 127 matching lines @@
                 // they're same groups affected by the parent transactions. So instead of
                 // respecting opts.XG for inner transactions, we just dup everything from
                 // the parent transaction.
                 roots = parentState.roots.Dup()
                 rootLimit = parentState.rootLimit
 
                 sizeBudget = parentState.sizeBudget - parentState.entState.total
                 writeCountBudget = parentState.writeCountBudget - parentState.entState.numWrites()
         }
 
-        bufDS, err := memory.NewDatastore(inf.FullyQualifiedAppID(), ns)
-        if err != nil {
-                return err
-        }
-
         state := &txnBufState{
                 entState:         &sizeTracker{},
-                bufDS:            bufDS.Raw(),
+                bufDS:            memory.NewDatastore(inf).Raw(),
                 roots:            roots,
                 rootLimit:        rootLimit,
                 ns:               ns,
-                aid:              inf.AppID(),
+                aid:              inf.FullyQualifiedAppID(),
                 parentDS:         datastore.Get(context.WithValue(ctx, dsTxnBufHaveLock, true)).Raw(),
                 sizeBudget:       sizeBudget,
                 writeCountBudget: writeCountBudget,
         }
-        if err = cb(context.WithValue(ctx, dsTxnBufParent, state)); err != nil {
+        if err := cb(context.WithValue(ctx, dsTxnBufParent, state)); err != nil {
                 return err
         }
 
         // no reason to unlock this ever. At this point it's toast.
         state.Lock()
 
         if parentState == nil {
                 return commitToReal(state)
         }
 
-        if err = parentState.canApplyLocked(state); err != nil {
+        if err := parentState.canApplyLocked(state); err != nil {
                 return err
         }
 
         parentState.commitLocked(state)
         return nil
 }
 
 // item is a temporary object for representing key/entity pairs and their cache
 // state (e.g. if they exist in the in-memory datastore buffer or not).
 // Additionally item memoizes some common comparison strings. item objects
@@ skipping 361 matching lines @@
 // plus a stringset of all the encoded root keys that `keys` represents.
 func toEncoded(keys []*datastore.Key) (full []string, roots stringset.Set) {
         roots = stringset.New(len(keys))
         full = make([]string, len(keys))
         for i, k := range keys {
                 roots.Add(string(serialize.ToBytes(k.Root())))
                 full[i] = string(serialize.ToBytes(k))
         }
         return
 }