Refactor a bit.

impl/memory/taskqueue_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 (
         "errors"
         "fmt"
         "net/http"
         "sync"
         "sync/atomic"
 
         "golang.org/x/net/context"
 
-        "github.com/luci/gae"
+        rds "github.com/luci/gae/service/rawdatastore"
+        tq "github.com/luci/gae/service/taskqueue"
         "github.com/luci/luci-go/common/clock"
 )
 
 var (
         currentNamespace = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace")
         defaultNamespace = http.CanonicalHeaderKey("X-AppEngine-Default-Namespace")
 )
 
 //////////////////////////////// taskQueueData /////////////////////////////////
 
 type taskQueueData struct {
         sync.Mutex
 
-        named    gae.QueueData
-        archived gae.QueueData
+        named    tq.QueueData
+        archived tq.QueueData
 }
 
 var (
         _ = memContextObj((*taskQueueData)(nil))
-        _ = gae.TQTestable((*taskQueueData)(nil))
+        _ = tq.Testable((*taskQueueData)(nil))
 )
 
 func newTaskQueueData() memContextObj {
         return &taskQueueData{
-                named:    gae.QueueData{"default": {}},
-                archived: gae.QueueData{"default": {}},
+                named:    tq.QueueData{"default": {}},
+                archived: tq.QueueData{"default": {}},
         }
 }
 
 func (t *taskQueueData) canApplyTxn(obj memContextObj) bool { return true }
 func (t *taskQueueData) endTxn()                            {}
 func (t *taskQueueData) applyTxn(c context.Context, obj memContextObj) {
         txn := obj.(*txnTaskQueueData)
         for qn, tasks := range txn.anony {
                 for _, tsk := range tasks {
                         tsk.Name = mkName(c, tsk.Name, t.named[qn])
                         t.named[qn][tsk.Name] = tsk
                 }
         }
         txn.anony = nil
 }
-func (t *taskQueueData) mkTxn(*gae.DSTransactionOptions) memContextObj {
+func (t *taskQueueData) mkTxn(*rds.TransactionOptions) memContextObj {
         return &txnTaskQueueData{
                 parent: t,
-                anony:  gae.AnonymousQueueData{},
+                anony:  tq.AnonymousQueueData{},
         }
 }
 
-func (t *taskQueueData) GetTransactionTasks() gae.AnonymousQueueData {
+func (t *taskQueueData) GetTransactionTasks() tq.AnonymousQueueData {
         return nil
 }
 
 func (t *taskQueueData) CreateQueue(queueName string) {
         t.Lock()
         defer t.Unlock()
 
         if _, ok := t.named[queueName]; ok {
                 panic(fmt.Errorf("memory/taskqueue: cannot add the same queue twice! %q", queueName))
         }
-        t.named[queueName] = map[string]*gae.TQTask{}
-        t.archived[queueName] = map[string]*gae.TQTask{}
+        t.named[queueName] = map[string]*tq.Task{}
+        t.archived[queueName] = map[string]*tq.Task{}
 }
 
-func (t *taskQueueData) GetScheduledTasks() gae.QueueData {
+func (t *taskQueueData) GetScheduledTasks() tq.QueueData {
         t.Lock()
         defer t.Unlock()
 
         return dupQueue(t.named)
 }
 
-func (t *taskQueueData) GetTombstonedTasks() gae.QueueData {
+func (t *taskQueueData) GetTombstonedTasks() tq.QueueData {
         t.Lock()
         defer t.Unlock()
 
         return dupQueue(t.archived)
 }
 
 func (t *taskQueueData) resetTasksWithLock() {
         for queueName := range t.named {
-                t.named[queueName] = map[string]*gae.TQTask{}
-                t.archived[queueName] = map[string]*gae.TQTask{}
+                t.named[queueName] = map[string]*tq.Task{}
+                t.archived[queueName] = map[string]*tq.Task{}
         }
 }
 
 func (t *taskQueueData) ResetTasks() {
         t.Lock()
         defer t.Unlock()
 
         t.resetTasksWithLock()
 }
 
 func (t *taskQueueData) getQueueName(queueName string) (string, error) {
         if queueName == "" {
                 queueName = "default"
         }
         if _, ok := t.named[queueName]; !ok {
                 return "", errors.New("UNKNOWN_QUEUE")
         }
         return queueName, nil
 }
 
 var tqOkMethods = map[string]struct{}{
         "GET":    {},
         "POST":   {},
         "HEAD":   {},
         "PUT":    {},
         "DELETE": {},
 }
 
-func (t *taskQueueData) prepTask(c context.Context, ns string, task *gae.TQTask, queueName string) (*gae.TQTask, string, error) {
+func (t *taskQueueData) prepTask(c context.Context, ns string, task *tq.Task, queueName string) (*tq.Task, string, error) {
         queueName, err := t.getQueueName(queueName)
         if err != nil {
                 return nil, "", err
         }
 
         toSched := dupTask(task)
 
         if toSched.Path == "" {
                 toSched.Path = "/_ah/queue/" + queueName
         }
@@ skipping 36 matching lines @@
         return toSched, queueName, nil
 }
 
 /////////////////////////////// txnTaskQueueData ///////////////////////////////
 
 type txnTaskQueueData struct {
         lock sync.Mutex
 
         // boolean 0 or 1, use atomic.*Int32 to access.
         closed int32
-        anony  gae.AnonymousQueueData
+        anony  tq.AnonymousQueueData
         parent *taskQueueData
 }
 
 var (
         _ = memContextObj((*txnTaskQueueData)(nil))
-        _ = gae.TQTestable((*txnTaskQueueData)(nil))
+        _ = tq.Testable((*txnTaskQueueData)(nil))
 )
 
-func (t *txnTaskQueueData) canApplyTxn(obj memContextObj) bool            { return false }
-func (t *txnTaskQueueData) applyTxn(context.Context, memContextObj)       { panic("impossible") }
-func (t *txnTaskQueueData) mkTxn(*gae.DSTransactionOptions) memContextObj { panic("impossible") }
+func (t *txnTaskQueueData) canApplyTxn(obj memContextObj) bool          { return false }
+func (t *txnTaskQueueData) applyTxn(context.Context, memContextObj)     { panic("impossible") }
+func (t *txnTaskQueueData) mkTxn(*rds.TransactionOptions) memContextObj { panic("impossible") }
 
 func (t *txnTaskQueueData) endTxn() {
         if atomic.LoadInt32(&t.closed) == 1 {
                 panic("cannot end transaction twice")
         }
         atomic.StoreInt32(&t.closed, 1)
 }
 
 func (t *txnTaskQueueData) run(f func() error) error {
         // Slightly different from the SDK... datastore and taskqueue each implement
@@ skipping 16 matching lines @@
 
 func (t *txnTaskQueueData) Lock() {
         t.lock.Lock()
         t.parent.Lock()
 }
 func (t *txnTaskQueueData) Unlock() {
         t.parent.Unlock()
         t.lock.Unlock()
 }
 
-func (t *txnTaskQueueData) GetTransactionTasks() gae.AnonymousQueueData {
+func (t *txnTaskQueueData) GetTransactionTasks() tq.AnonymousQueueData {
         t.Lock()
         defer t.Unlock()
 
-        ret := make(gae.AnonymousQueueData, len(t.anony))
+        ret := make(tq.AnonymousQueueData, len(t.anony))
         for k, vs := range t.anony {
-                ret[k] = make([]*gae.TQTask, len(vs))
+                ret[k] = make([]*tq.Task, len(vs))
                 for i, v := range vs {
                         tsk := dupTask(v)
                         tsk.Name = ""
                         ret[k][i] = tsk
                 }
         }
 
         return ret
 }
 
-func (t *txnTaskQueueData) GetTombstonedTasks() gae.QueueData {
+func (t *txnTaskQueueData) GetTombstonedTasks() tq.QueueData {
         return t.parent.GetTombstonedTasks()
 }
 
-func (t *txnTaskQueueData) GetScheduledTasks() gae.QueueData {
+func (t *txnTaskQueueData) GetScheduledTasks() tq.QueueData {
         return t.parent.GetScheduledTasks()
 }
 
 func (t *txnTaskQueueData) CreateQueue(queueName string) {
         t.parent.CreateQueue(queueName)
 }