Move WriteJSONFile to its sole caller's package, with some refactoring.

client/cmd/isolate/batch_archive.go

 // Copyright 2015 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 (
         "encoding/json"
         "errors"
         "fmt"
@@ skipping 158 matching lines @@
                         data[item.name] = item.Digest()
                         fmt.Printf("%s%s  %s\n", prefix, item.Digest(), item.name)
                 } else {
                         fmt.Fprintf(os.Stderr, "%s%s  %s\n", prefix, item.name, item.Error())
                 }
         }
         err = arch.Close()
         duration := time.Since(start)
         // Only write the file once upload is confirmed.
         if err == nil && c.dumpJSON != "" {
-                err = common.WriteJSONFile(c.dumpJSON, data)
+                err = writeJSONDigestFile(c.dumpJSON, data)
         }
         if !c.defaultFlags.Quiet {
                 stats := arch.Stats()
                 fmt.Fprintf(os.Stderr, "Hits    : %5d (%s)\n", stats.TotalHits(), stats.TotalBytesHits())
                 fmt.Fprintf(os.Stderr, "Misses  : %5d (%s)\n", stats.TotalMisses(), stats.TotalBytesPushed())
                 fmt.Fprintf(os.Stderr, "Duration: %s\n", units.Round(duration, time.Millisecond))
         }
         return err
 }
 
@@ skipping 39 matching lines @@
 // strippedIsolatedName returns the base name of an isolated path, with the extension (if any) removed.
 func strippedIsolatedName(isolated string) string {
         name := filepath.Base(isolated)
         // Strip the extension if there is one.
         if dotIndex := strings.LastIndex(name, "."); dotIndex != -1 {
                 return name[0:dotIndex]
         }
         return name
 }
 
+func writeJSONDigestFile(filePath string, data map[string]isolated.HexDigest) error {
+        digestBytes, err := json.MarshalIndent(data, "", "  ")
+        if err != nil {
+                return fmt.Errorf("encoding digest JSON: %s", err)
+        }
+        return writeFile(filePath, digestBytes)
+}
+
+// writeFile writes data to filePath. File permission is set to user only.
+func writeFile(filePath string, data []byte) error {
+        f, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+        if err != nil {
+                return fmt.Errorf("opening %s: %s", filePath, err)
+        }
+        // NOTE: We don't defer f.Close here, because it may return an error.
+
+        _, writeErr := f.Write(data)
+        closeErr := f.Close()
+        if writeErr != nil {
+                return fmt.Errorf("writing %s: %s", filePath, writeErr)
+        } else if closeErr != nil {
+                return fmt.Errorf("closing %s: %s", filePath, closeErr)
+        }
+        return nil
+}
+
 func (c *batchArchiveRun) Run(a subcommands.Application, args []string, _ subcommands.Env) int {
         if err := c.Parse(a, args); err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         cl, err := c.defaultFlags.StartTracing()
         if err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         defer cl.Close()
         if err := c.main(a, args); err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         return 0
 }