Add variables support to trace_test_cases.py, removing the last use of --product-dir.

tools/isolate/trace_test_cases.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.
 
 """Traces each test cases of a google-test executable individually.
 
 Gives detailed information about each test case. The logs can be read afterward
 with ./trace_inputs.py read -l /path/to/executable.logs
 """
@@ skipping 117 matching lines @@
   # Strips to root_dir.
   results_processed = {}
   for item in results:
     if 'results' in item:
       item = item.copy()
       item['results'] = item['results'].strip_root(root_dir)
       results_processed[item['trace']] = item
     else:
       print >> sys.stderr, 'Got exception while tracing %s: %s' % (
           item['trace'], item['exception'])
+  print '%.1fs Done stripping root.' % (
+      time.time() - progress.start)
 
   # Flatten.
   flattened = {}
   for item_list in values:
     for item in item_list:
       if item['valid']:
         test_case = item['test_case']
         tracename = test_case.replace('/', '-')
         flattened[test_case] = results_processed[tracename].copy()
         item_results = flattened[test_case]['results']
         flattened[test_case].update({
             'processes': len(list(item_results.process.all)),
             'results': item_results.flatten(),
             'duration': item['duration'],
             'returncode': item['returncode'],
             'valid': item['valid'],
             'variables':
-              isolate_common.generate_dict(
-                sorted(f.path for f in item_results.files),
-                cwd_dir,
-                variables['<(PRODUCT_DIR)']),
+              isolate_common.generate_simplified(
+                  item_results.existent,
+                  root_dir,
+                  variables,
+                  cwd_dir),
           })
         del flattened[test_case]['trace']
+  print '%.1fs Done flattening.' % (
+      time.time() - progress.start)
+
   # Make it dense if there is more than 20 results.
   trace_inputs.write_json(
       output_file,
       flattened,
       False)
 
   # Also write the .isolate file.
   # First, get all the files from all results. Use a map to remove dupes.
   files = {}
   for item in results_processed.itervalues():
     files.update((f.full_path, f) for f in item['results'].existent)
   # Convert back to a list, discard the keys.
   files = files.values()
 
-  # TODO(maruel): Have isolate_common process a dict of variables.
-  value = isolate_common.generate_dict(
-      sorted(f.path for f in files), cwd_dir, variables['<(PRODUCT_DIR)'])
+  value = isolate_common.generate_isolate(
+      files,
+      root_dir,
+      variables,
+      cwd_dir)
   with open('%s.isolate' % output_file, 'wb') as f:
     isolate_common.pretty_print(value, f)
   return 0
 
 
 def main():
   """CLI frontend to validate arguments."""
+  default_variables = [('OS', isolate_common.get_flavor())]
+  if sys.platform in ('win32', 'cygwin'):
+    default_variables.append(('EXECUTABLE_SUFFIX', '.exe'))
+  else:
+    default_variables.append(('EXECUTABLE_SUFFIX', ''))
   parser = optparse.OptionParser(
       usage='%prog <options> [gtest]',
       description=sys.modules['__main__'].__doc__)
   parser.format_description = lambda *_: parser.description
   parser.add_option(
       '-c', '--cwd',
       default='chrome',
       help='Signal to start the process from this relative directory. When '
            'specified, outputs the inputs files in a way compatible for '
            'gyp processing. Should be set to the relative path containing the '
            'gyp file, e.g. \'chrome\' or \'net\'')
   parser.add_option(
-      '-p', '--product-dir',
-      default='out/Release',
-      help='Directory for PRODUCT_DIR. Default: %default')
+      '-V', '--variable',
+      nargs=2,
+      action='append',
+      default=default_variables,
+      dest='variables',
+      metavar='FOO BAR',
+      help='Variables to process in the .isolate file, default: %default')
   parser.add_option(
       '--root-dir',
       default=ROOT_DIR,
       help='Root directory to base everything off. Default: %default')
   parser.add_option(
       '-o', '--out',
       help='output file, defaults to <executable>.test_cases')
   parser.add_option(
       '-w', '--whitelist',
       default=[],
       action='append',
       help='filter to apply to test cases to run, wildcard-style, defaults to '
            'all test')
   parser.add_option(
       '-b', '--blacklist',
       default=[],
       action='append',
       help='filter to apply to test cases to skip, wildcard-style, defaults to '
            'no test')
   parser.add_option(
       '-j', '--jobs',
       type='int',
       help='number of parallel jobs')
   parser.add_option(
       '-t', '--timeout',
       default=120,
       type='int',
       help='number of parallel jobs')
+  parser.add_option(
+      '-v', '--verbose',
+      action='count',
+      default=0,
+      help='Use multiple times to increase verbosity')
   options, args = parser.parse_args()
 
+  levels = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
+  logging.basicConfig(
+      level=levels[min(len(levels)-1, options.verbose)],
+      format='%(levelname)5s %(module)15s(%(lineno)3d): %(message)s')
+
   if len(args) != 1:
     parser.error(
         'Please provide the executable line to run, if you need fancy things '
         'like xvfb, start this script from *inside* xvfb, it\'ll be much faster'
         '.')
   executable = args[0]
   if not os.path.isabs(executable):
-    executable = os.path.join(options.root_dir, options.product_dir, args[0])
+    executable = os.path.abspath(os.path.join(options.root_dir, executable))
   if not options.out:
     options.out = '%s.test_cases' % executable
-  variables = {'<(PRODUCT_DIR)': options.product_dir}
   return trace_test_cases(
       executable,
       options.root_dir,
       options.cwd,
-      variables,
+      dict(options.variables),
       options.whitelist,
       options.blacklist,
       options.jobs,
       # TODO(maruel): options.timeout,
       options.out)
 
 
 if __name__ == '__main__':
   sys.exit(main())