Add Context cancellation to clock.

common/clock/testclock/testtimer.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 testclock
 
 import (
         "time"
 
         "github.com/luci/luci-go/common/clock"
+        "golang.org/x/net/context"
 )
 
 // timer is an implementation of clock.TestTimer that uses a channel
 // to signal the timer to fire.
 //
 // The channel is buffered so it can be used without requiring a separate
 // signalling goroutine.
 type timer struct {
-        clock   *testClock
-        signalC chan time.Time
+        ctx   context.Context
+        clock *testClock
+
+        // tags is the set of tags in the Context when this timer was created.
+        tags []string
+
+        // afterC will have the AfterResult of the timer's expiration written to it
+        // when this timer triggers or is canceled.
+        afterC chan clock.AfterResult
 
         // Cancels callback from clock.invokeAt. Being not nil implies that the timer
         // is active.
-        cancelFunc cancelFunc
+        cancelFunc context.CancelFunc
 }
 
 var _ clock.Timer = (*timer)(nil)
 
 // NewTimer returns a new, instantiated timer.
-func newTimer(clock *testClock) clock.Timer {
+func newTimer(ctx context.Context, clk *testClock) *timer {
         return &timer{
-                clock: clock,
+                ctx:    ctx,
+                clock:  clk,
+                tags:   clock.Tags(ctx),
+                afterC: make(chan clock.AfterResult, 1),
         }
 }
 
-func (t *timer) GetC() (c <-chan time.Time) {
-        if t.cancelFunc != nil {
-                c = t.signalC
-        }
-        return
+func (t *timer) GetC() <-chan clock.AfterResult {
+        return t.afterC
 }
 
 func (t *timer) Reset(d time.Duration) (active bool) {
         now := t.clock.Now()
         triggerTime := now.Add(d)
 
         // Signal our timerSet callback.
         t.clock.signalTimerSet(d, t)
 
         // Stop our current polling goroutine, if it's running.
         active = t.Stop()
 
         // Set timer properties.
-        t.signalC = make(chan time.Time, 1)
-        t.cancelFunc = t.clock.invokeAt(triggerTime, t.signal)
+        var ctx context.Context
+        ctx, t.cancelFunc = context.WithCancel(t.ctx)
+        t.clock.invokeAt(ctx, triggerTime, t.invokeCallback)
         return
 }
 
 func (t *timer) Stop() bool {
         // If the timer is not running, we're done.
         if t.cancelFunc == nil {
                 return false
         }
 
         // Clear our state.
         t.cancelFunc()
         t.cancelFunc = nil
         return true
 }
 
-// Sends a single time signal.
-func (t *timer) signal(now time.Time) {
-        if t.signalC != nil {
-                t.signalC <- now
+// invokeCallback sends a single time signal.
+func (t *timer) invokeCallback(now time.Time, err error) {
+        if t.afterC != nil {
+                t.afterC <- clock.AfterResult{Time: now, Err: err}
         }
 }