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 TimerResult of the timer's expiration written to it
+        // when this timer triggers or is canceled.
+        afterC chan clock.TimerResult
 
         // 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.TimerResult, 1),
         }
 }
 
-func (t *timer) GetC() (c <-chan time.Time) {
-        if t.cancelFunc != nil {
-                c = t.signalC
-        }
-        return
+func (t *timer) GetC() <-chan clock.TimerResult {
+        return t.afterC
 }
 
 func (t *timer) Reset(d time.Duration) (active bool) {
         now := t.clock.Now()
         triggerTime := now.Add(d)
 
         // Signal our timerSet callback.
+        afterC := make(chan clock.TimerResult, 1)
         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, func(now time.Time, err error) {
+                t.cancelFunc = nil

[iannucci, 2016/02/10 22:30:28]

Stop (https://golang.org/pkg/time/#Timer.Stop) shouldn't signal or close the
channel

[dnj (Google), 2016/02/11 01:26:54]

Done.

+                afterC <- clock.TimerResult{Time: now, Err: err}
+        })
+
+        t.afterC = afterC
         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
+// GetTags returns the tags associated with the specified timer. If the timer
+// has no tags, an empty slice (nil) will be returned.
+func GetTags(t clock.Timer) []string {
+        if tt, ok := t.(*timer); ok {
+                return clock.Tags(tt.ctx)
         }
+        return nil
 }
+
+// HasTags tests if a given timer has the same tags.
+func HasTags(t clock.Timer, tags ...string) bool {

[iannucci, 2016/02/10 22:30:28]

HasTags(t clock.Timer, first string, rest ...string) bool

[dnj (Google), 2016/02/11 01:26:54]

Done.

+        timerTags := GetTags(t)
+        if len(timerTags) != len(tags) {
+                return false
+        }
+        for i, tag := range timerTags {
+                if tags[i] != tag {
+                        return false
+                }
+        }
+        return true
+}