Fix a bug where deletions weren't updating the raw Kind index.

impl/memory/gkvlite_utils.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "bytes"
         "runtime"
-        "sync"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/gkvlite"
 )
 
 func gkvCollide(o, n memCollection, f func(k, ov, nv []byte)) {
         if o != nil && !o.IsReadOnly() {
                 panic("old collection is r/w")
         }
         if n != nil && !n.IsReadOnly() {
                 panic("new collection is r/w")
         }
 
         // TODO(riannucci): reimplement in terms of *iterator.
         oldItems, newItems := make(chan *gkvlite.Item), make(chan *gkvlite.Item)
-        walker := func(c memCollection, ch chan<- *gkvlite.Item, wg *sync.WaitGroup) {
+        walker := func(c memCollection, ch chan<- *gkvlite.Item) {
                 defer close(ch)
-                defer wg.Done()
                 if c != nil {
                         c.VisitItemsAscend(nil, true, func(i *gkvlite.Item) bool {
                                 ch <- i
                                 return true
                         })
                 }
         }
 
-        wg := &sync.WaitGroup{}
-        wg.Add(2)
-        go walker(o, oldItems, wg)
-        go walker(n, newItems, wg)
+        go walker(o, oldItems)
+        go walker(n, newItems)
 
         l, r := <-oldItems, <-newItems
         for {
-                if l == nil && r == nil {
-                        break
-                }
+                switch {
+                case l == nil && r == nil:
+                        return
 
-                if l == nil {
+                case l == nil:
                         f(r.Key, nil, r.Val)
                         r = <-newItems
-                } else if r == nil {
+
+                case r == nil:
                         f(l.Key, l.Val, nil)
                         l = <-oldItems
-                } else {
+
+                default:
                         switch bytes.Compare(l.Key, r.Key) {
                         case -1: // l < r
                                 f(l.Key, l.Val, nil)
                                 l = <-oldItems
                         case 0: // l == r
                                 f(l.Key, l.Val, r.Val)
                                 l, r = <-oldItems, <-newItems
                         case 1: // l > r
                                 f(r.Key, nil, r.Val)
                                 r = <-newItems
                         }
                 }
         }
-        wg.Wait()
 }
 
 // memStore is a gkvlite.Store which will panic for anything which might
 // otherwise return an error.
 //
 // This is reasonable for in-memory Store objects, since the only errors that
 // should occur happen with file IO on the underlying file (which of course
 // doesn't exist).
 type memStore interface {
         datastore.TestingSnapshot
@@ skipping 113 matching lines @@
         }
         err := mc.c.VisitItemsAscend(target, withValue, visitor)
         memoryCorruption(err)
 }
 
 func (mc *memCollectionImpl) GetTotals() (numItems, numBytes uint64) {
         numItems, numBytes, err := mc.c.GetTotals()
         memoryCorruption(err)
         return
 }