Clean up callback interfaces.

filter/txnBuf/ds_txn.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 (
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/errors"
         "golang.org/x/net/context"
@@ skipping 40 matching lines @@
 func (d *dsTxnBuf) Count(fq *ds.FinalizedQuery) (count int64, err error) {
         // Unfortunately there's no fast-path here. We literally have to run the
         // query and count. Fortunately we can optimize to count keys if it's not
         // a projection query. This will save on bandwidth a bit.
         if len(fq.Project()) == 0 && !fq.KeysOnly() {
                 fq, err = fq.Original().KeysOnly(true).Finalize()
                 if err != nil {
                         return
                 }
         }
-        err = d.Run(fq, func(_ *ds.Key, _ ds.PropertyMap, _ ds.CursorCB) bool {
+        err = d.Run(fq, func(_ *ds.Key, _ ds.PropertyMap, _ ds.CursorCB) error {
                 count++
-                return true
+                return nil
         })
         return
 }
 
 func (d *dsTxnBuf) Run(fq *ds.FinalizedQuery, cb ds.RawRunCB) error {
         if start, end := fq.Bounds(); start != nil || end != nil {
                 return errors.New("txnBuf filter does not support query cursors")
         }
 
         limit, limitSet := fq.Limit()
         offset, _ := fq.Offset()
         keysOnly := fq.KeysOnly()
 
         project := fq.Project()
 
         bufDS, parentDS, sizes := func() (ds.RawInterface, ds.RawInterface, *sizeTracker) {
                 if !d.haveLock {
                         d.state.Lock()
                         defer d.state.Unlock()
                 }
                 return d.state.bufDS, d.state.parentDS, d.state.entState.dup()
         }()
 
-        return runMergedQueries(fq, sizes, bufDS, parentDS, func(key *ds.Key, data ds.PropertyMap) bool {
+        return runMergedQueries(fq, sizes, bufDS, parentDS, func(key *ds.Key, data ds.PropertyMap) error {
                 if offset > 0 {
                         offset--
-                        return true
+                        return nil
                 }
                 if limitSet {
                         if limit == 0 {
-                                return false
+                                return ds.Stop
                         }
                         limit--
                 }
                 if keysOnly {
                         data = nil
                 } else if len(project) > 0 {
                         newData := make(ds.PropertyMap, len(project))
                         for _, p := range project {
                                 newData[p] = data[p]
                         }
                         data = newData
                 }
                 return cb(key, data, nil)
         })
 }
 
 func (d *dsTxnBuf) RunInTransaction(cb func(context.Context) error, opts *ds.TransactionOptions) error {
         if !d.haveLock {
                 d.state.Lock()
                 defer d.state.Unlock()
         }
         return withTxnBuf(d.ic, cb, opts)
 }
 
 func (d *dsTxnBuf) Testable() ds.Testable {
         return d.state.parentDS.Testable()
 }