Make appengine connection explicitly owned by impl/prod.

impl/prod/taskqueue.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 prod
 
 import (
         "fmt"
         "reflect"
 
         tq "github.com/luci/gae/service/taskqueue"
         "golang.org/x/net/context"
         "google.golang.org/appengine"
         "google.golang.org/appengine/taskqueue"
 )
 
 // useTQ adds a gae.TaskQueue implementation to context, accessible
 // by gae.GetTQ(c)
 func useTQ(c context.Context) context.Context {
         return tq.SetRawFactory(c, func(ci context.Context) tq.RawInterface {
-                return tqImpl{ci}
+                return tqImpl{AEContext(ci)}
         })
 }
 
 type tqImpl struct {
-        context.Context
+        aeCtx context.Context
 }
 
 func init() {
         const taskExpectedFields = 10
         // Runtime-assert that the number of fields in the Task structs match, to
         // avoid missing additional fields if they're added later.
         // all other type assertions are statically enforced by o2n() and tqF2R()
 
         oldType := reflect.TypeOf((*taskqueue.Task)(nil)).Elem()
         newType := reflect.TypeOf((*tq.Task)(nil)).Elem()
@@ skipping 42 matching lines @@
 // tqMF2R (TQ multi-fake-to-real) converts []*tq.Task to []*taskqueue.Task.
 func tqMF2R(ns []*tq.Task) []*taskqueue.Task {
         ret := make([]*taskqueue.Task, len(ns))
         for i, t := range ns {
                 ret[i] = tqF2R(t)
         }
         return ret
 }
 
 func (t tqImpl) AddMulti(tasks []*tq.Task, queueName string, cb tq.RawTaskCB) error {
-        realTasks, err := taskqueue.AddMulti(t.Context, tqMF2R(tasks), queueName)
+        realTasks, err := taskqueue.AddMulti(t.aeCtx, tqMF2R(tasks), queueName)
         if err != nil {
                 if me, ok := err.(appengine.MultiError); ok {
                         for i, err := range me {
                                 tsk := (*taskqueue.Task)(nil)
                                 if realTasks != nil {
                                         tsk = realTasks[i]
                                 }
                                 cb(tqR2F(tsk), err)
                         }
                         err = nil
                 }
         } else {
                 for _, tsk := range realTasks {
                         cb(tqR2F(tsk), nil)
                 }
         }
         return err
 }
 
 func (t tqImpl) DeleteMulti(tasks []*tq.Task, queueName string, cb tq.RawCB) error {
-        err := taskqueue.DeleteMulti(t.Context, tqMF2R(tasks), queueName)
+        err := taskqueue.DeleteMulti(t.aeCtx, tqMF2R(tasks), queueName)
         if me, ok := err.(appengine.MultiError); ok {
                 for _, err := range me {
                         cb(err)
                 }
                 err = nil
         }
         return err
 }
 
 func (t tqImpl) Purge(queueName string) error {
-        return taskqueue.Purge(t.Context, queueName)
+        return taskqueue.Purge(t.aeCtx, queueName)
 }
 
 func (t tqImpl) Stats(queueNames []string, cb tq.RawStatsCB) error {
-        stats, err := taskqueue.QueueStats(t.Context, queueNames)
+        stats, err := taskqueue.QueueStats(t.aeCtx, queueNames)
         if err != nil {
                 return err
         }
         for _, s := range stats {
                 cb((*tq.Statistics)(&s), nil)
         }
         return nil
 }
 
 func (t tqImpl) Testable() tq.Testable {
         return nil
 }