Replace ErrorExit with log.Fatal in the mojom tool.

mojom/mojom_parser/parse_cmd.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.
 
 /*
  This file contains parseCmd which parses a set of .mojom files and emits a
  serialized MojomFileGraph struct. See mojom_files.mojom for the definition of
  MojomFileGraph.
 
  The parse command is invoked as follows:
@@ skipping 15 matching lines @@
  data.
 */
 
 package main
 
 import (
         "bufio"
         "flag"
         "fmt"
         "io/ioutil"
+        "log"
         "mojom/mojom_parser/mojom"
         "mojom/mojom_parser/parser"
         "mojom/mojom_parser/serialization"
         "os"
         "path/filepath"
         "strings"
 )
 
 // DirectoryList holds the result of parsing a command-line flag
 // that accepts a comma-separated list of directory paths. This
@@ skipping 50 matching lines @@
                 fmt.Fprintln(os.Stderr, "No .mojom files given.")
                 printUsage()
                 os.Exit(1)
         }
 
         parseDriver := parser.NewDriver(directoryListFlag, *debug, *metaDataOnly)
 
         // Do the parsing
         descriptor, err := parseDriver.ParseFiles(fileNames)
         if err != nil {
-                ErrorExit(fmt.Sprintf("%s", err.Error()))
+                log.Fatalln(err.Error())
         } else if *debug {
                 fmt.Println("Parsing complete.")
         }
 
         // Serialize the result.
         bytes, debug_string, err := serialization.Serialize(descriptor, *debug)
         if err != nil {
-                ErrorExit(fmt.Sprintf("Serialization error: %s", err))
+                log.Fatalf("Serialization error: %s\n", err)
         }
 
         // In debug mode print out the debug information.
         if *debug {
                 PrintDebugOutput(debug_string, descriptor)
         }
 
         // Emit the output to a file or standard out.
         if len(*outFile) == 0 {
                 w := bufio.NewWriter(os.Stdout)
                 if _, err := w.Write(bytes); err != nil {
-                        ErrorExit(fmt.Sprintf("Error writing output to standard out: %s.", *outFile, err.Error()))
+                        log.Fatalf("Error writing output to standard out: %s.\n", err.Error())
                 }
                 w.Flush()
         } else {
                 if err := ioutil.WriteFile(*outFile, bytes, os.ModePerm); err != nil {
-                        ErrorExit(fmt.Sprintf("Error writing output to %s: %s.", *outFile, err.Error()))
+                        log.Fatalf("Error writing output to %s: %s.", *outFile, err.Error())
                 } else {
                         if *debug {
                                 fmt.Printf("The output was written to %s.\n", *outFile)
                         }
                 }
         }
 }
 
 func PrintDebugOutput(debugString string, descriptor *mojom.MojomDescriptor) {
         fmt.Println("\n\n=============================================")
         fmt.Println("\n Pre-Serialized Go Object:")
         fmt.Printf("\n%s\n", descriptor.String())
         fmt.Println("\n\n=============================================")
         fmt.Println("\n Debug Serialized Output:")
         fmt.Println(debugString)
 }