Add a --recursive flag to compare_build_artifacts and always look at the content of the *_apk subdi…

scripts/slave/recipe_modules/isolate/resources/compare_build_artifacts.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """Compare the artifacts from two builds."""
 
 import difflib
 import json
 import optparse
 import os
 import struct
 import sys
 import time
 
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
 
-def get_files_to_compare(build_dir):
+def get_files_to_compare(build_dir, recursive=False):
   """Get the list of files to compare."""
   allowed = frozenset(
       ('', '.apk', '.app', '.dll', '.dylib', '.exe', '.nexe', '.so'))
-
   def check(f):
     if not os.path.isfile(f):
       return False
     if os.path.basename(f).startswith('.'):
       return False
     ext = os.path.splitext(f)[1]
     if ext == '.isolated':
       return True
     return ext in allowed and os.access(f, os.X_OK)
 
-  return set(f for f in os.listdir(build_dir) if
-             check(os.path.join(build_dir, f)))
+  ret_files = set()
+  for root, dirs, files in os.walk(build_dir):
+    if not recursive:
+      dirs[:] = [d for d in dirs if d.endswith('_apk')]
+    for f in (f for f in files if check(os.path.join(root, f))):
+      ret_files.add(os.path.relpath(os.path.join(root, f), build_dir))
+  return ret_files
 
 
 def diff_dict(a, b):
   """Returns a yaml-like textural diff of two dict.
 
   It is currently optimized for the .isolated format.
   """
   out = ''
   for key in set(a) | set(b):
     va = a.get(key)
@@ skipping 65 matching lines @@
     # else, falls through binary comparison, it must be binary equal too.
 
   file_len = os.stat(first_filepath).st_size
   if file_len != os.stat(second_filepath).st_size:
     return 'different size: %d != %d' % (
         file_len, os.stat(second_filepath).st_size)
 
   return diff_binary(first_filepath, second_filepath, file_len)
 
 
-def compare_build_artifacts(first_dir, second_dir):
+def compare_build_artifacts(first_dir, second_dir, recursive=False):
   """Compare the artifacts from two distinct builds."""
   if not os.path.isdir(first_dir):
     print >> sys.stderr, '%s isn\'t a valid directory.' % first_dir
     return 1
   if not os.path.isdir(second_dir):
     print >> sys.stderr, '%s isn\'t a valid directory.' % second_dir
     return 1
 
   with open(os.path.join(BASE_DIR, 'deterministic_build_blacklist.json')) as f:
     blacklist = frozenset(json.load(f))
 
   res = 0
-  first_list = get_files_to_compare(first_dir) - blacklist
-  second_list = get_files_to_compare(second_dir) - blacklist
+  first_list = get_files_to_compare(first_dir, recursive) - blacklist
+  second_list = get_files_to_compare(second_dir, recursive) - blacklist
 
   diff = first_list.symmetric_difference(second_list)
   if diff:
     print >> sys.stderr, 'Different list of files in both directories'
     print >> sys.stderr, '\n'.join('  ' + i for i in sorted(diff))
     res += len(diff)
 
   epoch_hex = struct.pack('<I', int(time.time())).encode('hex')
   print('Epoch: %s' %
       ' '.join(epoch_hex[i:i+2] for i in xrange(0, len(epoch_hex), 2)))
@@ skipping 14 matching lines @@
 
   return 0 if res == 0 else 1
 
 
 def main():
   parser = optparse.OptionParser(usage='%prog [options]')
   parser.add_option(
       '-f', '--first-build-dir', help='The first build directory.')
   parser.add_option(
       '-s', '--second-build-dir', help='The second build directory.')
+  parser.add_option('-r', '--recursive', action='store_true', default=False,
+                    help='Indicates if the comparison should be recursive.')
   options, _ = parser.parse_args()
 
   if not options.first_build_dir:
     parser.error('--first-build-dir is required')
   if not options.second_build_dir:
     parser.error('--second-build-dir is required')
 
-  return compare_build_artifacts(options.first_build_dir,
-                                 options.second_build_dir)
+  return compare_build_artifacts(os.path.abspath(options.first_build_dir),
+                                 os.path.abspath(options.second_build_dir),
+                                 options.recursive)
 
 
 if __name__ == '__main__':
   sys.exit(main())