Clean up callback interfaces.

filter/dscache/ds.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 dscache
 
 import (
         "time"
 
         ds "github.com/luci/gae/service/datastore"
@@ skipping 39 matching lines @@
         }
 
         p := makeFetchPlan(d.c, d.aid, d.ns, &facts{keys, metas, lockItems, nonce})
 
         if !p.empty() {
                 // looks like we have something to pull from datastore, and maybe some work
                 // to save stuff back to memcache.
 
                 toCas := []memcache.Item{}
                 j := 0
-                err := d.RawInterface.GetMulti(p.toGet, p.toGetMeta, func(pm ds.PropertyMap, err error) {
+                err := d.RawInterface.GetMulti(p.toGet, p.toGetMeta, func(pm ds.PropertyMap, err error) error {
                         i := p.idxMap[j]
                         toSave := p.toSave[j]
                         j++
 
                         data := []byte(nil)
 
                         // true: save entity to memcache
                         // false: lock entity in memcache forever
                         shouldSave := true
                         if err == nil {
                                 p.decoded[i] = pm
                                 if toSave != nil {
                                         data = encodeItemValue(pm)
                                         if len(data) > internalValueSizeLimit {
                                                 shouldSave = false
                                                 log.Warningf(
                                                         d.c, "dscache: encoded entity too big (%d/%d)!",
                                                         len(data), internalValueSizeLimit)
                                         }
                                 }
                         } else {
                                 p.lme.Assign(i, err)
                                 if err != ds.ErrNoSuchEntity {
-                                        return // aka continue to the next entry
+                                        return nil // aka continue to the next entry
                                 }
                         }
 
                         if toSave != nil {
                                 if shouldSave { // save
                                         mg := metas.GetSingle(i)
                                         expSecs := ds.GetMetaDefault(mg, CacheExpirationMeta, CacheTimeSeconds).(int64)
                                         toSave.SetFlags(uint32(ItemHasData))
                                         toSave.SetExpiration(time.Duration(expSecs) * time.Second)
                                         toSave.SetValue(data)
                                 } else {
                                         // Set a lock with an infinite timeout. No one else should try to
                                         // serialize this item to memcache until something Put/Delete's it.
                                         toSave.SetFlags(uint32(ItemHasLock))
                                         toSave.SetExpiration(0)
                                         toSave.SetValue(nil)
                                 }
                                 toCas = append(toCas, toSave)
                         }
+                        return nil
                 })
                 if err != nil {
                         return err
                 }
                 if len(toCas) > 0 {
                         // we have entries to save back to memcache.
                         if err := d.mc.CompareAndSwapMulti(toCas); err != nil {
                                 (log.Fields{log.ErrorKey: err}).Warningf(
                                         d.c, "dscache: GetMulti: memcache.CompareAndSwapMulti")
                         }
@@ skipping 17 matching lines @@
                 if err == nil {
                         err = txnState.apply(d.supportContext)
                 }
                 return err
         }, opts)
         if err == nil {
                 txnState.release(d.supportContext)
         }
         return err
 }