Revert of V2 of //tools/binary_size rewrite (diffs).

tools/binary_size/create_html_breakdown.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.
 
 """Creates an html report that allows you to view binary size by component."""
 
 import argparse
 import json
 import logging
 import os
 import shutil
 import sys
 
+import analyze
 import helpers
-import map2size
 
 
 # Node dictionary keys. These are output in json read by the webapp so
 # keep them short to save file size.
 # Note: If these change, the webapp must also change.
 _NODE_TYPE_KEY = 'k'
 _NODE_TYPE_BUCKET = 'b'
 _NODE_TYPE_PATH = 'p'
 _NODE_TYPE_SYMBOL = 's'
 _NODE_NAME_KEY = 'n'
@@ skipping 79 matching lines @@
     node_name = symbol_name or '[Anonymous]'
   elif symbol_name.startswith('*'):
     node_name = symbol_name
   else:
     node_name = symbol_type
   node = _GetOrMakeChildNode(node, _NODE_TYPE_SYMBOL, node_name)
   node[_NODE_SYMBOL_SIZE_KEY] = node.get(_NODE_SYMBOL_SIZE_KEY, 0) + symbol_size
   node[_NODE_SYMBOL_TYPE_KEY] = symbol_type
 
 
-def _MakeCompactTree(symbols, include_symbols):
+def _MakeCompactTree(root_group, include_symbols):
   result = {
       _NODE_NAME_KEY: '/',
       _NODE_CHILDREN_KEY: {},
       _NODE_TYPE_KEY: 'p',
       _NODE_MAX_DEPTH_KEY: 0,
   }
-  for symbol in symbols:
+  for symbol in root_group:
     file_path = symbol.path or _NAME_NO_PATH_BUCKET
     node = result
     depth = 0
     for path_part in file_path.split(os.path.sep):
       if not path_part:
         continue
       depth += 1
       node = _GetOrMakeChildNode(node, _NODE_TYPE_PATH, path_part)
 
     symbol_type = symbol.section
-    if symbol.name.endswith('[vtable]'):
-      symbol_type = _NODE_SYMBOL_TYPE_VTABLE
-    elif symbol.name.endswith(']'):
-      symbol_type = _NODE_SYMBOL_TYPE_GENERATED
+    if symbol.name:
+      if symbol.name.endswith('[vtable]'):
+        symbol_type = _NODE_SYMBOL_TYPE_VTABLE
+      elif symbol.name.endswith(']'):
+        symbol_type = _NODE_SYMBOL_TYPE_GENERATED
     _AddSymbolIntoFileNode(node, symbol_type, symbol.name, symbol.size,
                            include_symbols)
     depth += 2
     result[_NODE_MAX_DEPTH_KEY] = max(result[_NODE_MAX_DEPTH_KEY], depth)
 
   # The (no path) bucket can be extremely large if we failed to get
   # path information. Split it into subgroups if needed.
   no_path_bucket = result[_NODE_CHILDREN_KEY].get(_NAME_NO_PATH_BUCKET)
   if no_path_bucket and include_symbols:
     _SplitLargeBucket(no_path_bucket)
 
   _MakeChildrenDictsIntoLists(result)
 
   return result
 
 
 def _CopyTemplateFiles(dest_dir):
   d3_out = os.path.join(dest_dir, 'd3')
   if not os.path.exists(d3_out):
     os.makedirs(d3_out, 0755)
   d3_src = os.path.join(helpers.SRC_ROOT, 'third_party', 'd3', 'src')
   template_src = os.path.join(os.path.dirname(__file__), 'template')
   shutil.copy(os.path.join(d3_src, 'LICENSE'), d3_out)
   shutil.copy(os.path.join(d3_src, 'd3.js'), d3_out)
   shutil.copy(os.path.join(template_src, 'index.html'), dest_dir)
   shutil.copy(os.path.join(template_src, 'D3SymbolTreeMap.js'), dest_dir)
 
 
-def main(argv):
+def main():
   parser = argparse.ArgumentParser()
-  parser.add_argument('input_file',
-                      help='Path to input file. Can be a linker .map file, or '
-                           'a .size file.')
   parser.add_argument('--report-dir', metavar='PATH', required=True,
                       help='Write output to the specified directory. An HTML '
                             'report is generated here.')
   parser.add_argument('--include-bss', action='store_true',
                       help='Include symbols from .bss (which consume no real '
                            'space)')
   parser.add_argument('--include-symbols', action='store_true',
                       help='Use per-symbol granularity rather than per-file.')
-  map2size.AddOptions(parser)
-  args = helpers.AddCommonOptionsAndParseArgs(parser, argv)
+  analyze.AddOptions(parser)
+  args = helpers.AddCommonOptionsAndParseArgs(parser)
 
-  size_info = map2size.AnalyzeWithArgs(args, args.input_file)
-  symbols = size_info.symbols
+  result = analyze.AnalyzeWithArgs(args)
+  root_group = result.symbol_group
   if not args.include_bss:
-    symbols = size_info.WhereInSection('b').Inverted()
-  symbols = symbols.WhereBiggerThan(0)
+    root_group = root_group.WhereInSection('b').Inverted()
+  root_group = root_group.WhereBiggerThan(0)
 
   # Copy report boilerplate into output directory. This also proves that the
   # output directory is safe for writing, so there should be no problems writing
   # the nm.out file later.
   _CopyTemplateFiles(args.report_dir)
 
   logging.info('Creating JSON objects')
-  tree_root = _MakeCompactTree(symbols, args.include_symbols)
+  tree_root = _MakeCompactTree(root_group, args.include_symbols)
 
   logging.info('Serializing')
   with open(os.path.join(args.report_dir, 'data.js'), 'w') as out_file:
     out_file.write('var tree_data=')
     # Use separators without whitespace to get a smaller file.
     json.dump(tree_root, out_file, ensure_ascii=False, check_circular=False,
               separators=(',', ':'))
 
   print 'Report saved to ' + args.report_dir + '/index.html'
 
-
 if __name__ == '__main__':
-  sys.exit(main(sys.argv))
+  sys.exit(main())