Allow depfile to depend on a Stamp file instead of the default first input.

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 98 matching lines @@
                     output_all_resource_defines attribute of the root <grit>
                     element of the input .grd file.
 
   --write-only-new flag
                     If flag is non-0, write output files to a temporary file
                     first, and copy it to the real output only if the new file
                     is different from the old file.  This allows some build
                     systems to realize that dependent build steps might be
                     unnecessary, at the cost of comparing the output data at
                     grit time.
-                    
+
+  --depend-on-stamp
+                    If specified along with --depfile and --depdir, the depfile
+                    generated will depend on a stampfile instead of the first
+                    output in the input .grd file.
 
 Conditional inclusion of resources only affects the output of files which
 control which resources get linked into a binary, e.g. it affects .rc files
 meant for compilation but it does not affect resource header files (that define
 IDs).  This helps ensure that values of IDs stay the same, that all messages
 are exported to translation interchange files (e.g. XMB files), etc.
 '''
 
   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 = []
     assert_output_files = []
     target_platform = None
     depfile = None
     depdir = None
     rc_header_format = None
     output_all_resource_defines = None
     write_only_new = False
+    depend_on_stamp = False
     (own_opts, args) = getopt.getopt(args, 'a:o:D:E:f:w:t:h:',
         ('depdir=','depfile=','assert-file-list=',
          'output-all-resource-defines',
          'no-output-all-resource-defines',
+         'depend-on-stamp',
          'write-only-new='))
     for (key, val) in own_opts:
       if key == '-a':
         assert_output_files.append(val)
       elif key == '--assert-file-list':
         with open(val) as f:
           assert_output_files += f.read().splitlines()
       elif key == '-o':
         self.output_directory = val
       elif key == '-D':
@@ skipping 16 matching lines @@
       elif key == '-t':
         target_platform = val
       elif key == '-h':
         rc_header_format = val
       elif key == '--depdir':
         depdir = val
       elif key == '--depfile':
         depfile = val
       elif key == '--write-only-new':
         write_only_new = val != '0'
+      elif key == '--depend-on-stamp':
+        depend_on_stamp = True
 
     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 26 matching lines @@
     if rc_header_format:
       self.res.AssignRcHeaderFormat(rc_header_format)
     self.res.RunGatherers()
     self.Process()
 
     if assert_output_files:
       if not self.CheckAssertedOutputFiles(assert_output_files):
         return 2
 
     if depfile and depdir:
-      self.GenerateDepfile(depfile, depdir, first_ids_file)
+      self.GenerateDepfile(depfile, depdir, first_ids_file, depend_on_stamp)
 
     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 178 matching lines @@
 %s
 Extra output files:
 %s
 '''
       print error % ('\n'.join(asserted), '\n'.join(actual), '\n'.join(missing),
           '\n'.join(extra))
       return False
     return True
 
 
-  def GenerateDepfile(self, depfile, depdir, first_ids_file):
+  def GenerateDepfile(self, depfile, depdir, first_ids_file, depend_on_stamp):
     '''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 |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 --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.h: ../src/input1.xtb ../src/input2.xtb
 
     Where "gen/blah.h" is the first output (Ninja expects the .d file to list
-    the first output in cases where there is more than one).
+    the first output in cases where there is more than one). If the flag
+    --depend-on-stamp is specified, "gen/blah.rd.d.stamp" will be used that is
+    'touched' whenever a new depfile is generated.
 
     Note that all paths in the depfile are relative to ../out, the depdir.
     '''
     depfile = os.path.abspath(depfile)
     depdir = os.path.abspath(depdir)
     infiles = self.res.GetInputFiles()
 
     # We want to trigger a rebuild if the first ids change.
     if first_ids_file is not None:
       infiles.append(first_ids_file)
 
-    # Get the first output file relative to the depdir.
-    outputs = self.res.GetOutputFiles()
-    output_file = os.path.relpath(os.path.join(
-          self.output_directory, outputs[0].GetFilename()), depdir)
+    if (depend_on_stamp):
+      output_file = depfile + ".stamp"
+      # Touch the stamp file before generating the depfile.
+      with open(output_file, 'a'):
+        os.utime(output_file, None)
+    else:
+      # Get the first output file relative to the depdir.
+      outputs = self.res.GetOutputFiles()
+      output_file = os.path.join(self.output_directory,
+                                 outputs[0].GetFilename())
 
+    output_file = os.path.relpath(output_file, depdir)
     # The path prefix to prepend to dependencies in the depfile.
     prefix = os.path.relpath(os.getcwd(), depdir)
     deps_text = ' '.join([os.path.join(prefix, i) for i in infiles])
 
     depfile_contents = output_file + ': ' + 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)