Make use of md5_check within process_resources.py

build/android/gyp/process_resources.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.
 
 """Process Android resources to generate R.java, and prepare for packaging.
 
 This will crunch images and generate v14 compatible resources
 (see generate_v14_compatible_resources.py).
@@ skipping 15 matching lines @@
 sys.path.insert(1,
     os.path.join(os.path.dirname(__file__), '../../../third_party'))
 from jinja2 import Template # pylint: disable=F0401
 
 
 # Represents a line from a R.txt file.
 TextSymbolsEntry = collections.namedtuple('RTextEntry',
     ('java_type', 'resource_type', 'name', 'value'))
 
 
-def ParseArgs(args):
+def _ParseArgs(args):
   """Parses command line options.
 
   Returns:
     An options object as from optparse.OptionsParser.parse_args()
   """
   parser = optparse.OptionParser()
   build_utils.AddDepfileOption(parser)
 
   parser.add_option('--android-sdk', help='path to the Android SDK folder')
   parser.add_option('--aapt-path',
@@ skipping 49 matching lines @@
       help='Include every resource ID in every generated R.java file '
       '(ignoring R.txt).')
 
   parser.add_option(
       '--all-resources-zip-out',
       help='Path for output of all resources. This includes resources in '
       'dependencies.')
 
   parser.add_option('--stamp', help='File to touch on success')
 
-  (options, args) = parser.parse_args(args)
+  options, positional_args = parser.parse_args(args)
 
-  if args:
+  if positional_args:
     parser.error('No positional arguments should be given.')
 
   # Check that required options have been provided.
   required_options = (
       'android_sdk',
       'aapt_path',
       'android_manifest',
       'dependencies_res_zips',
       'resource_dirs',
       'resource_zip_out',
       )
   build_utils.CheckOptions(options, parser, required=required_options)
 
   if (options.R_dir is None) == (options.srcjar_out is None):
     raise Exception('Exactly one of --R-dir or --srcjar-out must be specified.')
 
+  options.resource_dirs = build_utils.ParseGypList(options.resource_dirs)
+  options.dependencies_res_zips = (
+      build_utils.ParseGypList(options.dependencies_res_zips))
+
+  # Don't use [] as default value since some script explicitly pass "".
+  if options.extra_res_packages:
+    options.extra_res_packages = (
+        build_utils.ParseGypList(options.extra_res_packages))
+  else:
+    options.extra_res_packages = []
+
+  if options.extra_r_text_files:
+    options.extra_r_text_files = (
+        build_utils.ParseGypList(options.extra_r_text_files))
+  else:
+    options.extra_r_text_files = []
+
   return options
 
 
 def CreateExtraRJavaFiles(
       r_dir, extra_packages, extra_r_text_files, shared_resources, include_all):
   if include_all:
     java_files = build_utils.FindInDirectory(r_dir, "R.java")
     if len(java_files) != 1:
       return
     r_java_file = java_files[0]
@@ skipping 181 matching lines @@
   # of the form 0, 1, ..., then each subdirectory will be passed to aapt as a
   # resources directory. While some resources just clobber others (image files,
   # etc), other resources (particularly .xml files) need to be more
   # intelligently merged. That merging is left up to aapt.
   def path_transform(name, src_zip):
     return '%d/%s' % (zip_files.index(src_zip), name)
 
   build_utils.MergeZips(output_path, zip_files, path_transform=path_transform)
 
 
-def main():
-  args = build_utils.ExpandFileArgs(sys.argv[1:])
-
-  options = ParseArgs(args)
+def _OnStaleMd5(options):
   android_jar = os.path.join(options.android_sdk, 'android.jar')
   aapt = options.aapt_path
-
-  input_files = []
-
   with build_utils.TempDir() as temp_dir:
     deps_dir = os.path.join(temp_dir, 'deps')
     build_utils.MakeDirectory(deps_dir)
     v14_dir = os.path.join(temp_dir, 'v14')
     build_utils.MakeDirectory(v14_dir)
 
     gen_dir = os.path.join(temp_dir, 'gen')
     build_utils.MakeDirectory(gen_dir)
 
-    input_resource_dirs = build_utils.ParseGypList(options.resource_dirs)
+    input_resource_dirs = options.resource_dirs
 
     if not options.v14_skip:
       for resource_dir in input_resource_dirs:
         generate_v14_compatible_resources.GenerateV14Resources(
             resource_dir,
             v14_dir)
 
-    dep_zips = build_utils.ParseGypList(options.dependencies_res_zips)
-    input_files += dep_zips
+    dep_zips = options.dependencies_res_zips
     dep_subdirs = []
     for z in dep_zips:
       subdir = os.path.join(deps_dir, os.path.basename(z))
       if os.path.exists(subdir):
         raise Exception('Resource zip name conflict: ' + os.path.basename(z))
       build_utils.ExtractAll(z, path=subdir)
       dep_subdirs.append(subdir)
 
     # Generate R.java. This R.java contains non-final constants and is used only
     # while compiling the library jar (e.g. chromium_content.jar). When building
@@ skipping 24 matching lines @@
       package_command += ['-G', options.proguard_file]
     if options.shared_resources:
       package_command.append('--shared-lib')
     if options.app_as_shared_lib:
       package_command.append('--app-as-shared-lib')
     build_utils.CheckOutput(package_command, print_stderr=False)
 
     if options.extra_res_packages:
       CreateExtraRJavaFiles(
           gen_dir,
-          build_utils.ParseGypList(options.extra_res_packages),
-          build_utils.ParseGypList(options.extra_r_text_files),
+          options.extra_res_packages,
+          options.extra_r_text_files,
           options.shared_resources,
           options.include_all_resources)
 
     # This is the list of directories with resources to put in the final .zip
     # file. The order of these is important so that crunched/v14 resources
     # override the normal ones.
     zip_resource_dirs = input_resource_dirs + [v14_dir]
 
     base_crunch_dir = os.path.join(temp_dir, 'crunch')
 
@@ skipping 18 matching lines @@
     else:
       build_utils.ZipDir(options.srcjar_out, gen_dir)
 
     if options.r_text_out:
       r_text_path = os.path.join(gen_dir, 'R.txt')
       if os.path.exists(r_text_path):
         shutil.copyfile(r_text_path, options.r_text_out)
       else:
         open(options.r_text_out, 'w').close()
 
-  if options.depfile:
-    input_files += build_utils.GetPythonDependencies()
-    build_utils.WriteDepfile(options.depfile, input_files)
 
-  if options.stamp:
-    build_utils.Touch(options.stamp)
+def main(args):
+  args = build_utils.ExpandFileArgs(args)
+  options = _ParseArgs(args)
+
+  possible_output_paths = [
+    options.resource_zip_out,
+    options.all_resources_zip_out,
+    options.r_text_out,
+    options.srcjar_out,
+  ]
+  output_paths = [x for x in possible_output_paths if x]
+
+  # List python deps in input_strings rather than input_paths since the contents
+  # of them does not change what gets written to the depsfile.
+  input_strings = options.extra_res_packages + [
+    options.aapt_path,
+    options.android_sdk,
+    options.app_as_shared_lib,
+    options.custom_package,
+    options.include_all_resources,
+    options.non_constant_id,
+    options.shared_resources,
+    options.v14_skip,
+  ]
+
+  input_paths = [ options.android_manifest ]
+  input_paths.extend(options.dependencies_res_zips)
+  input_paths.extend(options.extra_r_text_files)
+
+  if options.proguard_file:
+    input_paths.append(options.proguard_file)
+
+  for d in options.resource_dirs:
+    for root, _, filenames in os.walk(d):
+      input_paths.extend(os.path.join(root, f) for f in filenames)
+
+  build_utils.CallAndWriteDepfileIfStale(
+      lambda: _OnStaleMd5(options),
+      options,
+      input_paths=input_paths,
+      input_strings=input_strings,
+      output_paths=output_paths,
+      # TODO(agrieve): Remove R_dir when it's no longer used (used only by GYP).
+      force=options.R_dir)
 
 
 if __name__ == '__main__':
-  main()
+  main(sys.argv[1:])