Add a --depfile flag that explicitly names the generated depfile.

grit/tool/build.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 '''The 'grit build' tool along with integration for this tool with the
 SCons build system.
 '''
 
 import filecmp
@@ skipping 80 matching lines @@
 '''
 
   def ShortDescription(self):
     return 'A tool that builds RC files for compilation.'
 
   def Run(self, opts, args):
     self.output_directory = '.'
     first_ids_file = None
     whitelist_filenames = []
     target_platform = None
-    dep_dir = None
-    (own_opts, args) = getopt.getopt(args, 'o:D:E:f:w:t:', ('dep-dir=',))
+    depfile = None
+    depdir = None
+    (own_opts, args) = getopt.getopt(args, 'o:D:E:f:w:t:', ('depdir=','depfile='))
     for (key, val) in own_opts:
       if key == '-o':
         self.output_directory = val
       elif key == '-D':
         name, val = util.ParseDefine(val)
         self.defines[name] = val
       elif key == '-E':
         (env_name, env_value) = val.split('=', 1)
         os.environ[env_name] = env_value
       elif key == '-f':
         # TODO(joi@chromium.org): Remove this override once change
         # lands in WebKit.grd to specify the first_ids_file in the
         # .grd itself.
         first_ids_file = val
       elif key == '-w':
         whitelist_filenames.append(val)
       elif key == '-t':
         target_platform = val
-      elif key == '--dep-dir':
-        dep_dir = val
+      elif key == '--depdir':
+        depdir = val
+      elif key == '--depfile':
+        depfile = val
 
     if len(args):
       print 'This tool takes no tool-specific arguments.'
       return 2
     self.SetOptions(opts)
     if self.scons_targets:
       self.VerboseOut('Using SCons targets to identify files to output.\n')
     else:
       self.VerboseOut('Output directory: %s (absolute path: %s)\n' %
                       (self.output_directory,
@@ skipping 11 matching lines @@
                                 first_ids_file=first_ids_file,
                                 defines=self.defines,
                                 target_platform=target_platform)
     # Set an output context so that conditionals can use defines during the
     # gathering stage; we use a dummy language here since we are not outputting
     # a specific language.
     self.res.SetOutputLanguage('en')
     self.res.RunGatherers()
     self.Process()
 
-    if dep_dir:
-      self.GenerateDepfile(opts.input, dep_dir)
+    if depfile and depdir:
+      self.GenerateDepfile(opts.input, depfile, depdir)
 
     return 0
 
   def __init__(self, defines=None):
     # Default file-creation function is built-in open().  Only done to allow
     # overriding by unit test.
     self.fo_create = open
 
     # key/value pairs of C-preprocessor like defines that are used for
     # conditional output of resources
@@ skipping 137 matching lines @@
     # exit with an error code if there are missing translations in a non-pseudo
     # and non-official build.
     warnings = (self.res.UberClique().MissingTranslationsReport().
         encode('ascii', 'replace'))
     if warnings:
       self.VerboseOut(warnings)
     if self.res.UberClique().HasMissingTranslations():
       print self.res.UberClique().missing_translations_
       sys.exit(-1)
 
-  def GenerateDepfile(self, input_filename, dep_dir):
+  def GenerateDepfile(self, input_filename, depfile, depdir):
     '''Generate a depfile that contains the imlicit dependencies of the input
     grd. The depfile will be in the same format as a makefile, and will contain
-    references to files relative to |dep_dir|. It will be put in the same
-    directory as the generated outputs.
+    references to files relative to |depdir|. It will be put in |depfile|.
 
     For example, supposing we have three files in a directory src/
 
     src/
       blah.grd    <- depends on input{1,2}.xtb
       input1.xtb
       input2.xtb
 
     and we run
 
-      grit -i blah.grd -o ../out/gen --dep-dir ../out
+      grit -i blah.grd -o ../out/gen --depdir ../out --depfile ../out/gen/blah.rd.d
 
     from the directory src/ we will generate a depfile ../out/gen/blah.grd.d
     that has the contents
 
       gen/blah.grd.d: ../src/input1.xtb ../src/input2.xtb
 
-    Note that all paths in the depfile are relative to ../out, the dep-dir.
+    Note that all paths in the depfile are relative to ../out, the depdir.
     '''
-    depsfile_basename = os.path.basename(input_filename + '.d')
-    depfile = os.path.abspath(
-        os.path.join(self.output_directory, depsfile_basename))
-    dep_dir = os.path.abspath(dep_dir)
+    depfile = os.path.abspath(depfile)
+    depdir = os.path.abspath(depdir)
     # The path prefix to prepend to dependencies in the depfile.
-    prefix = os.path.relpath(os.getcwd(), dep_dir)
+    prefix = os.path.relpath(os.getcwd(), depdir)
     # The path that the depfile refers to itself by.
-    self_ref_depfile = os.path.relpath(depfile, dep_dir)
+    self_ref_depfile = os.path.relpath(depfile, depdir)
     infiles = self.res.GetInputFiles()
     deps_text = ' '.join([os.path.join(prefix, i) for i in infiles])
     depfile_contents = self_ref_depfile + ': ' + deps_text
     self.MakeDirectoriesTo(depfile)
     outfile = self.fo_create(depfile, 'wb')
     outfile.writelines(depfile_contents)
 
   @staticmethod
   def MakeDirectoriesTo(file):
     '''Creates directories necessary to contain |file|.'''
     dir = os.path.split(file)[0]
     if not os.path.exists(dir):
       os.makedirs(dir)