Revert "Refactor current GAE abstraction library to be free of the SDK*"

go/src/infra/gae/libs/wrapper/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"
 
         "golang.org/x/net/context"
 
-        "infra/gae/libs/gae"
+        "appengine/datastore"
 )
 
 type memContextObj interface {
         sync.Locker
         canApplyTxn(m memContextObj) bool
         applyTxn(c context.Context, m memContextObj)
 
         endTxn()
-        mkTxn(*gae.DSTransactionOptions) (memContextObj, error)
+        mkTxn(*datastore.TransactionOptions) (memContextObj, error)
 }
 
 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, error) {
+func (m memContext) mkTxn(o *datastore.TransactionOptions) (memContextObj, error) {
         ret := make(memContext, len(m))
         for i, itm := range m {
                 newItm, err := itm.mkTxn(o)
                 if err != nil {
                         return nil, err
                 }
                 ret[i] = newItm
         }
         return ret, nil
 }
@@ skipping 54 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 *datastore.TransactionOptions) error {
         curMC := cur(d.c)
 
         txnMC, err := curMC.mkTxn(o)
         if err != nil {
                 return err
         }
 
         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 datastore.ErrConcurrentTransaction
         }
         return nil
 }