Clean up callback interfaces.

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 246 matching lines @@
                                 data[i].buffered = true
                                 if size > 0 {
                                         idxMap = append(idxMap, i)
                                         toGetKeys = append(toGetKeys, key)
                                 }
                         }
                 }
 
                 if len(toGetKeys) > 0 {
                         j := 0
-                        t.bufDS.GetMulti(toGetKeys, nil, func(pm datastore.PropertyMap, err error) {
+                        t.bufDS.GetMulti(toGetKeys, nil, func(pm datastore.PropertyMap, err error) error {
                                 impossible(err)
                                 data[idxMap[j]].data = pm
                                 j++
+                                return nil
                         })
                 }
 
                 idxMap = nil
                 getKeys := []*datastore.Key(nil)
                 getMetas := datastore.MultiMetaGetter(nil)
 
                 for i, itm := range data {
                         if !itm.buffered {
                                 idxMap = append(idxMap, i)
                                 getKeys = append(getKeys, itm.key)
                                 getMetas = append(getMetas, metas.GetSingle(i))
                         }
                 }
 
                 if len(idxMap) > 0 {
                         j := 0
-                        err := t.parentDS.GetMulti(getKeys, getMetas, func(pm datastore.PropertyMap, err error) {
+                        err := t.parentDS.GetMulti(getKeys, getMetas, func(pm datastore.PropertyMap, err error) error {
                                 if err != datastore.ErrNoSuchEntity {
                                         i := idxMap[j]
                                         if !lme.Assign(i, err) {
                                                 data[i].data = pm
                                         }
                                 }
                                 j++
+                                return nil
                         })
                         if err != nil {
                                 return err
                         }
                 }
                 return nil
         }()
         if err != nil {
                 return err
         }
@@ skipping 18 matching lines @@
                 if !haveLock {
                         t.Lock()
                         defer t.Unlock()
                 }
 
                 if err := t.updateRootsLocked(roots); err != nil {
                         return err
                 }
 
                 i := 0
-                err := t.bufDS.DeleteMulti(keys, func(err error) {
+                err := t.bufDS.DeleteMulti(keys, func(err error) error {
                         impossible(err)
                         t.entState.set(encKeys[i], 0)
                         i++
+                        return nil
                 })
                 impossible(err)
                 return nil
         }()
         if err != nil {
                 return err
         }
 
         for range keys {
                 cb(nil)
@@ skipping 44 matching lines @@
                 if !haveLock {
                         t.Lock()
                         defer t.Unlock()
                 }
 
                 if err := t.updateRootsLocked(roots); err != nil {
                         return err
                 }
 
                 i := 0
-                err := t.bufDS.PutMulti(keys, vals, func(k *datastore.Key, err error) {
+                err := t.bufDS.PutMulti(keys, vals, func(k *datastore.Key, err error) error {
                         impossible(err)
                         t.entState.set(encKeys[i], vals[i].EstimateSize())
                         i++
+                        return nil
                 })
                 impossible(err)
                 return nil
         }()
         if err != nil {
                 return err
         }
 
         for _, k := range keys {
                 cb(k, nil)
         }
         return nil
 }
 
 func commitToReal(s *txnBufState) error {
         toPut, toPutKeys, toDel := s.effect()
 
         return parallel.FanOutIn(func(ch chan<- func() error) {
                 if len(toPut) > 0 {
                         ch <- func() error {
                                 mErr := errors.NewLazyMultiError(len(toPut))
                                 i := 0
-                                err := s.parentDS.PutMulti(toPutKeys, toPut, func(_ *datastore.Key, err error) {
+                                err := s.parentDS.PutMulti(toPutKeys, toPut, func(_ *datastore.Key, err error) error {
                                         mErr.Assign(i, err)
                                         i++
+                                        return nil
                                 })
                                 if err == nil {
                                         err = mErr.Get()
                                 }
                                 return err
                         }
                 }
                 if len(toDel) > 0 {
                         ch <- func() error {
                                 mErr := errors.NewLazyMultiError(len(toDel))
                                 i := 0
-                                err := s.parentDS.DeleteMulti(toDel, func(err error) {
+                                err := s.parentDS.DeleteMulti(toDel, func(err error) error {
                                         mErr.Assign(i, err)
                                         i++
+                                        return nil
                                 })
                                 if err == nil {
                                         err = mErr.Get()
                                 }
                                 return err
                         }
                 }
         })
 }
 
 func (t *txnBufState) effect() (toPut []datastore.PropertyMap, toPutKeys, toDel []*datastore.Key) {
         // TODO(riannucci): preallocate return slices
 
         // need to pull all items out of the in-memory datastore. Fortunately we have
         // kindless queries, and we disabled all the special entities, so just
         // run a kindless query without any filters and it will return all data
         // currently in bufDS :).
         fq, err := datastore.NewQuery("").Finalize()
         impossible(err)
 
-        err = t.bufDS.Run(fq, func(key *datastore.Key, data datastore.PropertyMap, _ datastore.CursorCB) bool {
+        err = t.bufDS.Run(fq, func(key *datastore.Key, data datastore.PropertyMap, _ datastore.CursorCB) error {
                 toPutKeys = append(toPutKeys, key)
                 toPut = append(toPut, data)
-                return true
+                return nil
         })
         memoryCorruption(err)
 
         for keyStr, size := range t.entState.keyToSize {
                 if size == 0 {
                         k, err := serialize.ReadKey(bytes.NewBufferString(keyStr), serialize.WithoutContext, t.aid, t.ns)
                         memoryCorruption(err)
                         toDel = append(toDel, k)
                 }
         }
@@ skipping 11 matching lines @@
                 return ErrTransactionTooLarge
         }
         return nil
 }
 
 func (t *txnBufState) commitLocked(s *txnBufState) {
         toPut, toPutKeys, toDel := s.effect()
 
         if len(toPut) > 0 {
                 impossible(t.putMulti(toPutKeys, toPut,
-                        func(_ *datastore.Key, err error) { impossible(err) }, true))
+                        func(_ *datastore.Key, err error) error { return err }, true))
         }
 
         if len(toDel) > 0 {
-                impossible(t.deleteMulti(toDel, impossible, true))
+                impossible(t.deleteMulti(toDel, func(err error) error { return err }, true))
         }
 }
 
 // toEncoded returns a list of all of the serialized versions of these keys,
 // 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
 }