client/isolate: add context to NewChecker func

client/cmd/isolate/checker.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package main
 
 import (
         "log"
         "time"
 
@@ skipping 20 matching lines @@
 type checkerItem struct {
         item     *Item
         isolated bool
         callback CheckerCallback
 }
 
 // Checker uses the isolatedclient.Client to check whether items are available
 // on the server.
 // Checker methods are safe to call concurrently.
 type Checker struct {
+        ctx     context.Context
         svc     isolateService
         bundler *bundler.Bundler
         err     error
 
         Hit, Miss CountBytes
 }
 
 // CountBytes aggregates a count of files and the number of bytes in them.
 type CountBytes struct {
         Count int
         Bytes int64
 }
 
 func (cb *CountBytes) addFile(size int64) {
         cb.Count++
         cb.Bytes += size
 }
 
 // NewChecker creates a NewChecker with the given isolated client.
-func NewChecker(client *isolatedclient.Client) *Checker {
-        return newChecker(client)
+// The provided context is used to make all requests to the isolate server.
+func NewChecker(ctx context.Context, client *isolatedclient.Client) *Checker {
+        return newChecker(ctx, client)
 }
 
-func newChecker(svc isolateService) *Checker {
+func newChecker(ctx context.Context, svc isolateService) *Checker {
         c := &Checker{
                 svc: svc,
         }
         c.bundler = bundler.NewBundler(checkerItem{}, func(bundle interface{}) {
                 items := bundle.([]checkerItem)
                 if c.err != nil {
                         for _, item := range items {
                                 // Drop any more incoming items.
                                 log.Printf("WARNING dropped %q from Checker", item.item.Path)
                         }
@@ skipping 34 matching lines @@
 // one invocation at a time.
 func (c *Checker) check(items []checkerItem) error {
         var digests []*service.HandlersEndpointsV1Digest
         for _, item := range items {
                 digests = append(digests, &service.HandlersEndpointsV1Digest{
                         Digest:     string(item.item.Digest),
                         Size:       item.item.Size,
                         IsIsolated: item.isolated,
                 })
         }
-        out, err := c.svc.Contains(context.Background(), digests)
+        out, err := c.svc.Contains(c.ctx, digests)
         if err != nil {
                 return err
         }
         for i, item := range items {
                 if size := item.item.Size; out[i] == nil {
                         c.Hit.addFile(size)
                 } else {
                         c.Miss.addFile(size)
                 }
 
                 item.callback(item.item, out[i])
         }
         return nil
 }