Don't filter "Stop" error in raw interface.

impl/memory/datastore_data.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 memory
 
 import (
         "bytes"
         "fmt"
         "sync"
@@ skipping 265 matching lines @@
                                 if oldPM, err = rpm(old); err != nil {
                                         return
                                 }
                         }
                         ents.Set(keyBytes(ret), dataBytes)
                         updateIndexes(d.head, ret, oldPM, pmap)
                         return
                 }()
                 if cb != nil {
                         if err := cb(k, err); err != nil {
-                                if err == ds.Stop {
-                                        return nil
-                                }
                                 return err
                         }
                 }
         }
         return nil
 }
 
 func getMultiInner(keys []*ds.Key, cb ds.GetMultiCB, getColl func() (*memCollection, error)) error {
         ents, err := getColl()
         if err != nil {
@@ skipping 52 matching lines @@
                                         if err != nil {
                                                 return err
                                         }
                                         ents.Delete(kb)
                                         updateIndexes(d.head, k, oldPM, nil)
                                 }
                                 return nil
                         }()
                         if cb != nil {
                                 if err := cb(err); err != nil {
-                                        if err == ds.Stop {
-                                                return nil
-                                        }
                                         return err
                                 }
                         }
                 }
         } else if cb != nil {
                 for range keys {
                         if err := cb(nil); err != nil {
-                                if err == ds.Stop {
-                                        return nil
-                                }
                                 return err
                         }
                 }
         }
         return nil
 }
 
 func (d *dataStoreData) canApplyTxn(obj memContextObj) bool {
         // TODO(riannucci): implement with Flush/FlushRevert for persistance.
 
@@ skipping 188 matching lines @@
 }
 
 func keyBytes(key *ds.Key) []byte {
         return serialize.ToBytes(ds.MkProperty(key))
 }
 
 func rpm(data []byte) (ds.PropertyMap, error) {
         return serialize.ReadPropertyMap(bytes.NewBuffer(data),
                 serialize.WithContext, "", "")
 }