Fix another race.

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 259 matching lines @@
                                 incrementLocked(ents, groupMetaKey(ret), 1)
                         }
 
                         old := ents.Get(keyBytes(ret))
                         oldPM := ds.PropertyMap(nil)
                         if old != nil {
                                 if oldPM, err = rpm(old); err != nil {
                                         return
                                 }
                         }
+                        ents.Set(keyBytes(ret), dataBytes)
                         updateIndexes(d.head, ret, oldPM, pmap)
-                        ents.Set(keyBytes(ret), dataBytes)
                         return
                 }()
                 if cb != nil {
                         cb(k, err)
                 }
         }
 }
 
 func getMultiInner(keys []*ds.Key, cb ds.GetMultiCB, getColl func() (*memCollection, error)) error {
         ents, err := getColl()
@@ skipping 46 matching lines @@
                                 ents := d.mutableEntsLocked(ns)
 
                                 if !d.disableSpecialEntities {
                                         incrementLocked(ents, groupMetaKey(k), 1)
                                 }
                                 if old := ents.Get(kb); old != nil {
                                         oldPM, err := rpm(old)
                                         if err != nil {
                                                 return err
                                         }
+                                        ents.Delete(kb)
                                         updateIndexes(d.head, k, oldPM, nil)
-                                        ents.Delete(kb)
                                 }
                                 return nil
                         }()
                         if cb != nil {
                                 cb(err)
                         }
                 }
         } else if cb != nil {
                 for range keys {
                         cb(nil)
@@ skipping 197 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, "", "")
 }