Add gn args to metadata and metadata diffing

tools/binary_size/map2size.py

 #!/usr/bin/env python
 # Copyright 2017 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.
 
 """Main Python API for analyzing binary size."""
 
 import argparse
 import calendar
 import datetime
@@ skipping 271 matching lines @@
   args = [tool_prefix + 'readelf', '-S', '--wide', elf_path]
   stdout = subprocess.check_output(args)
   section_sizes = {}
   # Matches  [ 2] .hash HASH 00000000006681f0 0001f0 003154 04   A  3   0  8
   for match in re.finditer(r'\[[\s\d]+\] (\..*)$', stdout, re.MULTILINE):
     items = match.group(1).split()
     section_sizes[items[0]] = int(items[4], 16)
   return section_sizes
 
 
+def _ParseGnArgs(args_path):
+  """Returns a list of normalized "key=value" strings."""
+  args = {}
+  with open(args_path) as f:
+    for l in f:
+      # Strips #s even if within string literal. Not a problem in practice.
+      parts = l.split('#')[0].split('=')
+      if len(parts) != 2:
+        continue
+      args[parts[0].strip()] = parts[1].strip()
+  return ["%s=%s" % x for x in sorted(args.iteritems())]
+
+
 def main(argv):
   parser = argparse.ArgumentParser(argv)
   parser.add_argument('elf_file', help='Path to input ELF file.')
   parser.add_argument('output_file', help='Path to output .size(.gz) file.')
   parser.add_argument('--map-file',
                       help='Path to input .map(.gz) file. Defaults to '
                            '{{elf_file}}.map(.gz)?')
   paths.AddOptions(parser)
   args = helpers.AddCommonOptionsAndParseArgs(parser, argv)
   if not args.output_file.endswith('.size'):
@@ skipping 14 matching lines @@
 
   lazy_paths = paths.LazyPaths(args=args, input_file=args.elf_file)
   metadata = None
   if args.elf_file and not args.elf_file.endswith('.size'):
     logging.debug('Constructing metadata')
     git_rev = _DetectGitRevision(os.path.dirname(args.elf_file))
     build_id = BuildIdFromElf(args.elf_file, lazy_paths.tool_prefix)
     timestamp_obj = datetime.datetime.utcfromtimestamp(os.path.getmtime(
         args.elf_file))
     timestamp = calendar.timegm(timestamp_obj.timetuple())
+    gn_args = _ParseGnArgs(os.path.join(lazy_paths.output_directory, 'args.gn'))
 
     def relative_to_out(path):
       return os.path.relpath(path, lazy_paths.VerifyOutputDirectory())
 
     metadata = {
         models.METADATA_GIT_REVISION: git_rev,
         models.METADATA_MAP_FILENAME: relative_to_out(map_file_path),
         models.METADATA_ELF_FILENAME: relative_to_out(args.elf_file),
         models.METADATA_ELF_MTIME: timestamp,
         models.METADATA_ELF_BUILD_ID: build_id,
+        models.METADATA_GN_ARGS: gn_args,
     }
 
   size_info = Analyze(map_file_path, lazy_paths)
 
   if metadata:
     logging.debug('Validating section sizes')
     elf_section_sizes = _SectionSizesFromElf(args.elf_file,
                                              lazy_paths.tool_prefix)
     for k, v in elf_section_sizes.iteritems():
       assert v == size_info.section_sizes.get(k), (
           'ELF file and .map file do not match.')
 
     size_info.metadata = metadata
 
-  logging.info('Recording metadata: %s',
-               describe.DescribeSizeInfoMetadata(size_info))
+  logging.info('Recording metadata: \n  %s',
+               '\n  '.join(describe.DescribeMetadata(size_info.metadata)))
   logging.info('Saving result to %s', args.output_file)
   file_format.SaveSizeInfo(size_info, args.output_file)
   logging.info('Done')
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))