Add Context cancellation to clock.

common/clock/systemtimer.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 clock
 
 import (
         "time"
+
+        "golang.org/x/net/context"
 )
 
 type systemTimer struct {
-        T *time.Timer // The underlying timer. Starts as nil, is initialized on Reset.
+        // base is the underlying timer. It starts as nil, and is initialized on
+        // Reset.
+        ctx context.Context

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

base? ctx?

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

Done.

+
+        // timerC is the current timer channel.
+        timerC chan TimerResult
+        // timerDoneC is a signal channel to alert our monitor that this timer has
+        // been canceled.
+        timerStoppedC chan struct{}

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

comments

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

Done.

+        // timerMonitorResultC returns true if the timer monitor was prematurely
+        // terminated, false if not.
+        timerMonitorResultC chan bool
 }
 
 var _ Timer = (*systemTimer)(nil)
 
-func (t *systemTimer) GetC() <-chan time.Time {
-        if t.T == nil {
-                return nil
-        }
-        return t.T.C
+func (t *systemTimer) GetC() <-chan TimerResult {
+        return t.timerC
 }
 
-func (t *systemTimer) Reset(d time.Duration) bool {
-        if t.T == nil {
-                t.T = time.NewTimer(d)
-                return false
+func (t *systemTimer) Reset(d time.Duration) (running bool) {
+        running = t.Stop()
+        t.reset()
+
+        // If our Context is already done, finish immediately.
+        select {

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

I'd use t.ctx.Err() instead

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

Done.

+        case <-t.ctx.Done():
+                t.timerC <- TimerResult{Time: time.Now(), Err: t.ctx.Err()}
+                return
+        default:
+                break
         }
-        return t.T.Reset(d)
+
+        // Start a monitor goroutine and our actual timer. Copy our channels, since
+        // future stop/reset will change the systemTimer's values and our goroutine
+        // should only operate on this round's values.
+        timerC := t.timerC
+        timerStoppedC := make(chan struct{})
+        timerMonitorResultC := make(chan bool, 1)
+        go func() {
+                interrupted := false
+                defer func() {
+                        timerMonitorResultC <- interrupted
+                }()
+
+                select {
+                case <-timerStoppedC:
+                        interrupted = true
+
+                case <-t.ctx.Done():
+                        timerC <- TimerResult{Time: time.Now(), Err: t.ctx.Err()}
+                case now := <-time.After(d):
+                        // For determinism, prioritize Context cancellation over timer expiration.
+                        select {
+                        case <-t.ctx.Done():
+                                timerC <- TimerResult{Time: now, Err: t.ctx.Err()}
+                        default:
+                                break
+                        }

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

also Err()

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

Done.

+
+                        timerC <- TimerResult{Time: now}
+                }
+        }()
+
+        t.timerStoppedC = timerStoppedC
+        t.timerMonitorResultC = timerMonitorResultC
+        return
 }
 
 func (t *systemTimer) Stop() bool {
-        if t.T == nil {
+        if t.timerStoppedC == nil {
                 return false
         }
-        return t.T.Stop()
+        close(t.timerStoppedC)
+        t.timerStoppedC = nil
+        return <-t.timerMonitorResultC
 }
+
+func (t *systemTimer) reset() {

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

let's inline this

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

Done.

+        t.timerC = make(chan TimerResult, 1)
+}