binary_size: Remove legacy path, keep / as / for unittests on windows

tools/binary_size/run_binary_size_analysis.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.
 
 """Generate a spatial analysis against an arbitrary library.
 
 To use, build the 'binary_size_tool' target. Then run this tool, passing
 in the location of the library to be analyzed along with any other options
 you desire.
 """
 
 import collections
 import json
 import logging
 import multiprocessing
 import optparse
 import os
 import re
 import shutil
 import struct
 import subprocess
 import sys
 import tempfile
 import time
 
 import binary_size_utils
 
-# This path changee is not beautiful. Temporary (I hope) measure until
+# This path change is not beautiful. Temporary (I hope) measure until
 # the chromium project has figured out a proper way to organize the
 # library of python tools. http://crbug.com/375725
 elf_symbolizer_path = os.path.abspath(os.path.join(
     os.path.dirname(__file__),
     '..',
     '..',
     'build',
     'android',
     'pylib'))
 sys.path.append(elf_symbolizer_path)
@@ skipping 173 matching lines @@
   SplitNoPathBucket(result)
 
   largest_list_len = MakeChildrenDictsIntoLists(result)
 
   if largest_list_len > BIG_BUCKET_LIMIT:
     logging.warning('There are sections with %d nodes. '
                     'Results might be unusable.' % largest_list_len)
   return result
 
 
-# TODO(andrewhayden): Only used for legacy reports. Delete.
-def TreeifySymbols(symbols):
-  """Convert symbols into a path-based tree, calculating size information
-  along the way.
-
-  The result is a dictionary that contains two kinds of nodes:
-  1. Leaf nodes, representing source code locations (e.g., c++ files)
-     These nodes have the following dictionary entries:
-       sizes: a dictionary whose keys are categories (such as code, data,
-              vtable, etceteras) and whose values are the size, in bytes, of
-              those categories;
-       size:  the total size, in bytes, of all the entries in the sizes dict
-  2. Non-leaf nodes, representing directories
-     These nodes have the following dictionary entries:
-       children: a dictionary whose keys are names (path entries; either
-                 directory or file names) and whose values are other nodes;
-       size:     the total size, in bytes, of all the leaf nodes that are
-                 contained within the children dict (recursively expanded)
-
-  The result object is itself a dictionary that represents the common ancestor
-  of all child nodes, e.g. a path to which all other nodes beneath it are
-  relative. The 'size' attribute of this dict yields the sum of the size of all
-  leaf nodes within the data structure.
-  """
-  dirs = {'children': {}, 'size': 0}
-  for sym, symbol_type, size, path in symbols:
-    dirs['size'] += size
-    if path:
-      path = os.path.normpath(path)
-      if path.startswith('/'):
-        path = path[1:]
-
-    parts = None
-    if path:
-      parts = path.split('/')
-
-    if parts:
-      assert path
-      file_key = parts.pop()
-      tree = dirs
-      try:
-        # Traverse the tree to the parent of the file node, creating as needed
-        for part in parts:
-          assert part != ''
-          if part not in tree['children']:
-            tree['children'][part] = {'children': {}, 'size': 0}
-          tree = tree['children'][part]
-          tree['size'] += size
-
-        # Get (creating if necessary) the node for the file
-        # This node doesn't have a 'children' attribute
-        if file_key not in tree['children']:
-          tree['children'][file_key] = {'sizes': collections.defaultdict(int),
-                                        'size': 0}
-        tree = tree['children'][file_key]
-        tree['size'] += size
-
-        # Accumulate size into a bucket within the file
-        symbol_type = symbol_type.lower()
-        if 'vtable for ' in sym:
-          tree['sizes']['[vtable]'] += size
-        elif 'r' == symbol_type:
-          tree['sizes']['[rodata]'] += size
-        elif 'd' == symbol_type:
-          tree['sizes']['[data]'] += size
-        elif 'b' == symbol_type:
-          tree['sizes']['[bss]'] += size
-        elif 't' == symbol_type:
-          # 'text' in binary parlance means 'code'.
-          tree['sizes']['[code]'] += size
-        elif 'w' == symbol_type:
-          tree['sizes']['[weak]'] += size
-        else:
-          tree['sizes']['[other]'] += size
-      except:
-        print >> sys.stderr, sym, parts, file_key
-        raise
-    else:
-      key = 'symbols without paths'
-      if key not in dirs['children']:
-        dirs['children'][key] = {'sizes': collections.defaultdict(int),
-                                 'size': 0}
-      tree = dirs['children'][key]
-      subkey = 'misc'
-      if (sym.endswith('::__FUNCTION__') or
-        sym.endswith('::__PRETTY_FUNCTION__')):
-        subkey = '__FUNCTION__'
-      elif sym.startswith('CSWTCH.'):
-        subkey = 'CSWTCH'
-      elif '::' in sym:
-        subkey = sym[0:sym.find('::') + 2]
-      tree['sizes'][subkey] = tree['sizes'].get(subkey, 0) + size
-      tree['size'] += size
-  return dirs
-
-
-# TODO(andrewhayden): Only used for legacy reports. Delete.
-def JsonifyTree(tree, name):
-  """Convert TreeifySymbols output to a JSON treemap.
-
-  The format is very similar, with the notable exceptions being
-  lists of children instead of maps and some different attribute names."""
-  children = []
-  css_class_map = {
-                  '[vtable]': 'vtable',
-                  '[rodata]': 'read-only_data',
-                  '[data]': 'data',
-                  '[bss]': 'bss',
-                  '[code]': 'code',
-                  '[weak]': 'weak_symbol'
-  }
-  if 'children' in tree:
-    # Non-leaf node. Recurse.
-    for child_name, child in tree['children'].iteritems():
-      children.append(JsonifyTree(child, child_name))
-  else:
-    # Leaf node; dump per-file stats as entries in the treemap
-    for kind, size in tree['sizes'].iteritems():
-      child_json = {'name': kind + ' (' + FormatBytes(size) + ')',
-                   'data': { '$area': size }}
-      css_class = css_class_map.get(kind)
-      if css_class is not None:
-        child_json['data']['$symbol'] = css_class
-      children.append(child_json)
-  # Sort children by size, largest to smallest.
-  children.sort(key=lambda child: -child['data']['$area'])
-
-  # For leaf nodes, the 'size' attribute is the size of the leaf;
-  # Non-leaf nodes don't really have a size, but their 'size' attribute is
-  # the sum of the sizes of all their children.
-  return {'name': name + ' (' + FormatBytes(tree['size']) + ')',
-          'data': { '$area': tree['size'] },
-          'children': children }
-
 def DumpCompactTree(symbols, symbol_path_origin_dir, outfile):
   tree_root = MakeCompactTree(symbols, symbol_path_origin_dir)
   with open(outfile, 'w') as out:
     out.write('var tree_data=')
     # Use separators without whitespace to get a smaller file.
     json.dump(tree_root, out, separators=(',', ':'))
   print('Writing %d bytes json' % os.path.getsize(outfile))
 
 
-# TODO(andrewhayden): Only used for legacy reports. Delete.
-def DumpTreemap(symbols, outfile):
-  dirs = TreeifySymbols(symbols)
-  out = open(outfile, 'w')
-  try:
-    out.write('var kTree = ' + json.dumps(JsonifyTree(dirs, '/')))
-  finally:
-    out.flush()
-    out.close()
-
-
-# TODO(andrewhayden): Only used for legacy reports. Delete.
-def DumpLargestSymbols(symbols, outfile, n):
-  # a list of (sym, symbol_type, size, path); sort by size.
-  symbols = sorted(symbols, key=lambda x: -x[2])
-  dumped = 0
-  out = open(outfile, 'w')
-  try:
-    out.write('var largestSymbols = [\n')
-    for sym, symbol_type, size, path in symbols:
-      if symbol_type in ('b', 'w'):
-        continue  # skip bss and weak symbols
-      if path is None:
-        path = ''
-      entry = {'size': FormatBytes(size),
-               'symbol': sym,
-               'type': SymbolTypeToHuman(symbol_type),
-               'location': path }
-      out.write(json.dumps(entry))
-      out.write(',\n')
-      dumped += 1
-      if dumped >= n:
-        return
-  finally:
-    out.write('];\n')
-    out.flush()
-    out.close()
-
-
 def MakeSourceMap(symbols):
   sources = {}
   for _sym, _symbol_type, size, path in symbols:
     key = None
     if path:
       key = os.path.normpath(path)
     else:
       key = '[no path]'
     if key not in sources:
       sources[key] = {'path': path, 'symbol_count': 0, 'size': 0}
     record = sources[key]
     record['size'] += size
     record['symbol_count'] += 1
   return sources
 
 
-# TODO(andrewhayden): Only used for legacy reports. Delete.
-def DumpLargestSources(symbols, outfile, n):
-  source_map = MakeSourceMap(symbols)
-  sources = sorted(source_map.values(), key=lambda x: -x['size'])
-  dumped = 0
-  out = open(outfile, 'w')
-  try:
-    out.write('var largestSources = [\n')
-    for record in sources:
-      entry = {'size': FormatBytes(record['size']),
-               'symbol_count': str(record['symbol_count']),
-               'location': record['path']}
-      out.write(json.dumps(entry))
-      out.write(',\n')
-      dumped += 1
-      if dumped >= n:
-        return
-  finally:
-    out.write('];\n')
-    out.flush()
-    out.close()
-
-
-# TODO(andrewhayden): Only used for legacy reports. Delete.
-def DumpLargestVTables(symbols, outfile, n):
-  vtables = []
-  for symbol, _type, size, path in symbols:
-    if 'vtable for ' in symbol:
-      vtables.append({'symbol': symbol, 'path': path, 'size': size})
-  vtables = sorted(vtables, key=lambda x: -x['size'])
-  dumped = 0
-  out = open(outfile, 'w')
-  try:
-    out.write('var largestVTables = [\n')
-    for record in vtables:
-      entry = {'size': FormatBytes(record['size']),
-               'symbol': record['symbol'],
-               'location': record['path']}
-      out.write(json.dumps(entry))
-      out.write(',\n')
-      dumped += 1
-      if dumped >= n:
-        return
-  finally:
-    out.write('];\n')
-    out.flush()
-    out.close()
-
-
 # Regex for parsing "nm" output. A sample line looks like this:
 # 0167b39c 00000018 t ACCESS_DESCRIPTION_free /path/file.c:95
 #
 # The fields are: address, size, type, name, source location
 # Regular expression explained ( see also: https://xkcd.com/208 ):
 # ([0-9a-f]{8,}+)   The address
 # [\s]+             Whitespace separator
 # ([0-9a-f]{8,}+)   The size. From here on out it's all optional.
 # [\s]+             Whitespace separator
 # (\S?)             The symbol type, which is any non-whitespace char
@@ skipping 399 matching lines @@
                          opts.disable_disambiguation is None,
                          opts.source_path)
 
   if opts.pak:
     AddPakData(symbols, opts.pak)
 
   if not os.path.exists(opts.destdir):
     os.makedirs(opts.destdir, 0755)
 
 
-  if opts.legacy: # legacy report
-    DumpTreemap(symbols, os.path.join(opts.destdir, 'treemap-dump.js'))
-    DumpLargestSymbols(symbols,
-                         os.path.join(opts.destdir, 'largest-symbols.js'), 100)
-    DumpLargestSources(symbols,
-                         os.path.join(opts.destdir, 'largest-sources.js'), 100)
-    DumpLargestVTables(symbols,
-                         os.path.join(opts.destdir, 'largest-vtables.js'), 100)
-    treemap_out = os.path.join(opts.destdir, 'webtreemap')
-    if not os.path.exists(treemap_out):
-      os.makedirs(treemap_out, 0755)
-    treemap_src = os.path.join('third_party', 'webtreemap', 'src')
-    shutil.copy(os.path.join(treemap_src, 'COPYING'), treemap_out)
-    shutil.copy(os.path.join(treemap_src, 'webtreemap.js'), treemap_out)
-    shutil.copy(os.path.join(treemap_src, 'webtreemap.css'), treemap_out)
-    shutil.copy(os.path.join('tools', 'binary_size', 'legacy_template',
-                             'index.html'), opts.destdir)
-  else: # modern report
-    if opts.library:
-      symbol_path_origin_dir = os.path.dirname(os.path.abspath(opts.library))
-    else:
-      # Just a guess. Hopefully all paths in the input file are absolute.
-      symbol_path_origin_dir = os.path.abspath(os.getcwd())
-    data_js_file_name = os.path.join(opts.destdir, 'data.js')
-    DumpCompactTree(symbols, symbol_path_origin_dir, data_js_file_name)
-    d3_out = os.path.join(opts.destdir, 'd3')
-    if not os.path.exists(d3_out):
-      os.makedirs(d3_out, 0755)
-    d3_src = os.path.join(os.path.dirname(__file__),
-                          '..',
-                          '..',
-                          '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'), opts.destdir)
-    shutil.copy(os.path.join(template_src, 'D3SymbolTreeMap.js'), opts.destdir)
+  if opts.library:
+    symbol_path_origin_dir = os.path.dirname(os.path.abspath(opts.library))
+  else:
+    # Just a guess. Hopefully all paths in the input file are absolute.
+    symbol_path_origin_dir = os.path.abspath(os.getcwd())
+  data_js_file_name = os.path.join(opts.destdir, 'data.js')
+  DumpCompactTree(symbols, symbol_path_origin_dir, data_js_file_name)
+  d3_out = os.path.join(opts.destdir, 'd3')
+  if not os.path.exists(d3_out):
+    os.makedirs(d3_out, 0755)
+  d3_src = os.path.join(os.path.dirname(__file__),
+                        '..',
+                        '..',
+                        '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'), opts.destdir)
+  shutil.copy(os.path.join(template_src, 'D3SymbolTreeMap.js'), opts.destdir)
 
   print 'Report saved to ' + opts.destdir + '/index.html'
 
 
 if __name__ == '__main__':
   sys.exit(main())