Refactor a bit.

impl/memory/context.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 (
         "errors"
         "sync"
 
-        "github.com/luci/gae"
+        rds "github.com/luci/gae/service/rawdatastore"
         "golang.org/x/net/context"
 )
 
 type memContextObj interface {
         sync.Locker
         canApplyTxn(m memContextObj) bool
         applyTxn(c context.Context, m memContextObj)
 
         endTxn()
-        mkTxn(*gae.DSTransactionOptions) memContextObj
+        mkTxn(*rds.TransactionOptions) memContextObj
 }
 
 type memContext []memContextObj
 
 var _ = memContextObj((memContext)(nil))
 
 func newMemContext() memContext {
         return memContext{
                 newTaskQueueData(),
                 newDataStoreData(),
@@ skipping 22 matching lines @@
                 m[i].Unlock()
         }
 }
 
 func (m memContext) endTxn() {
         for _, itm := range m {
                 itm.endTxn()
         }
 }
 
-func (m memContext) mkTxn(o *gae.DSTransactionOptions) memContextObj {
+func (m memContext) mkTxn(o *rds.TransactionOptions) memContextObj {
         ret := make(memContext, len(m))
         for i, itm := range m {
                 ret[i] = itm.mkTxn(o)
         }
         return ret
 }
 
 func (m memContext) canApplyTxn(txnCtxObj memContextObj) bool {
         txnCtx := txnCtxObj.(memContext)
         for i := range m {
@@ skipping 50 matching lines @@
 // a couple ways, for example.
 //
 // It really should have been appengine.Context.RunInTransaction(func(tc...)),
 // but because it's not, this method is on dsImpl instead to mirror the official
 // API.
 //
 // The fake implementation also differs from the real implementation because the
 // fake TaskQueue is NOT backed by the fake Datastore. This is done to make the
 // test-access API for TaskQueue better (instead of trying to reconstitute the
 // state of the task queue from a bunch of datastore accesses).
-func (d *dsImpl) RunInTransaction(f func(context.Context) error, o *gae.DSTransactionOptions) error {
+func (d *dsImpl) RunInTransaction(f func(context.Context) error, o *rds.TransactionOptions) error {
         curMC := cur(d.c)
 
         txnMC := curMC.mkTxn(o)
 
         defer func() {
                 txnMC.Lock()
                 defer txnMC.Unlock()
 
                 txnMC.endTxn()
         }()
 
         if err := f(context.WithValue(d.c, memContextKey, txnMC)); err != nil {
                 return err
         }
 
         txnMC.Lock()
         defer txnMC.Unlock()
 
         if curMC.canApplyTxn(txnMC) {
                 curMC.applyTxn(d.c, txnMC)
         } else {
-                return gae.ErrDSConcurrentTransaction
+                return rds.ErrConcurrentTransaction
         }
         return nil
 }