Add Context cancellation to clock.

common/clock/systemclock.go

 // Copyright 2014 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"
 )
 
 // Implementation of Clock that uses Go's standard library.
 type systemClock struct{}
 
 // System clock instance.
 var systemClockInstance systemClock
 
 var _ Clock = systemClock{}
 
 // GetSystemClock returns an instance of a Clock whose method calls directly use
 // Go's "time" library.
 func GetSystemClock() Clock {
         return systemClockInstance
 }
 
 func (systemClock) Now() time.Time {
         return time.Now()
 }
 
-func (systemClock) Sleep(d time.Duration) {
-        time.Sleep(d)
+func (sc systemClock) Sleep(c context.Context, d time.Duration) error {
+        ar := <-sc.After(c, d)
+        return ar.Err
 }
 
-func (systemClock) NewTimer() Timer {
-        return new(systemTimer)
+func (systemClock) NewTimer(ctx context.Context) Timer {
+        t := systemTimer{
+                ctx: ctx,
+        }
+        t.reset()
+        return &t
 }
 
-func (systemClock) After(d time.Duration) <-chan time.Time {
-        return time.After(d)
+func (systemClock) After(c context.Context, d time.Duration) <-chan AfterResult {
+        ac := make(chan AfterResult)
+        go func() {

[dnj (Google), 2016/02/10 03:19:03]

I implemented this separately from systemtimer b/c it is slightly more
lightweight. Not opposed to making this a NewTimer / <-GetC() call like system
and testclock do.

+                ar := AfterResult{}
+
+                select {
+                case <-c.Done():
+                        ar.Err = c.Err()
+
+                case tm := <-time.After(d):
+                        // For determinism, prefer context cancellation over full sleep.
+                        select {
+                        case <-c.Done():
+                                ar.Err = c.Err()
+                        default:
+                                ar.Time = tm
+                        }
+                }
+                ac <- ar
+        }()
+        return ac
 }