diagnose_bloat.py: swap --silent with --verbose.

tools/binary_size/diagnose_bloat.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.
 
-"""Tool for finding the cause of APK bloat.
+"""Tool for finding the cause of binary size bloat.
 
-Run diagnose_apk_bloat.py -h for detailed usage help.
+See //tools/binary_size/README.md for example usage.
+
+Note: this tool will perform gclient sync/git checkout on your local repo if
+you don't use the --cloud option.
 """
 
 import atexit
 import argparse
 import collections
 from contextlib import contextmanager
 import distutils.spawn
 import json
 import logging
 import multiprocessing
 import os
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 import zipfile
 
 _COMMIT_COUNT_WARN_THRESHOLD = 15
 _ALLOWED_CONSECUTIVE_FAILURES = 2
 _DIFF_DETAILS_LINES_THRESHOLD = 100
-_BUILDER_URL = \
-    'https://build.chromium.org/p/chromium.perf/builders/Android%20Builder'
 _SRC_ROOT = os.path.abspath(
     os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))
 _DEFAULT_ARCHIVE_DIR = os.path.join(_SRC_ROOT, 'binary-size-bloat')
 _DEFAULT_OUT_DIR = os.path.join(_SRC_ROOT, 'out', 'diagnose-apk-bloat')
 _DEFAULT_ANDROID_TARGET = 'monochrome_public_apk'
 
 
 _DiffResult = collections.namedtuple('DiffResult', ['name', 'value', 'units'])
 
 
@@ skipping 165 matching lines @@
     elif 'monochrome' in self.target:
       return 'lib.unstripped/libmonochrome.so'
     else:
       return 'lib.unstripped/libchrome.so'
 
   @property
   def abs_main_lib_path(self):
     return os.path.join(self.output_directory, self.main_lib_path)
 
   @property
+  def builder_url(self):
+    url = 'https://build.chromium.org/p/chromium.perf/builders/%s%%20Builder'
+    return url % self.target_os.title()
+
+  @property
   def download_bucket(self):
     return 'gs://chrome-perf/%s Builder/' % self.target_os.title()
 
   @property
   def download_output_dir(self):
     return 'out/Release' if self.IsAndroid() else 'full-build-linux'
 
   @property
   def map_file_path(self):
     return self.main_lib_path + '.map.gz'
@@ skipping 14 matching lines @@
       self.extra_gn_args_str = ' is_chrome_branded=true'
     else:
       self.extra_gn_args_str = (' exclude_unwind_tables=true '
           'ffmpeg_branding="Chrome" proprietary_codecs=true')
     self.target = self.target if self.IsAndroid() else 'chrome'
 
   def _GenGnCmd(self):
     gn_args = 'is_official_build=true symbol_level=1'
     gn_args += ' use_goma=%s' % str(self.use_goma).lower()
     gn_args += ' target_os="%s"' % self.target_os
-    gn_args += (' enable_chrome_android_internal=%s' %
-                str(self.enable_chrome_android_internal).lower())
+    if self.IsAndroid():
+      gn_args += (' enable_chrome_android_internal=%s' %
+                  str(self.enable_chrome_android_internal).lower())
     gn_args += self.extra_gn_args_str
     return ['gn', 'gen', self.output_directory, '--args=%s' % gn_args]
 
   def _GenNinjaCmd(self):
     cmd = ['ninja', '-C', self.output_directory]
     cmd += ['-j', self.max_jobs] if self.max_jobs else []
     cmd += ['-l', self.max_load_average] if self.max_load_average else []
     cmd += [self.target]
     return cmd
 
   def Run(self):
     """Run GN gen/ninja build and return the process returncode."""
-    logging.info('Building: %s.', self.target)
+    logging.info('Building: %s (this might take a while).', self.target)
     retcode = _RunCmd(
         self._GenGnCmd(), verbose=True, exit_on_failure=False)[1]
     if retcode:
       return retcode
     return _RunCmd(
         self._GenNinjaCmd(), verbose=True, exit_on_failure=False)[1]
 
   def DownloadUrl(self, rev):
     return self.download_bucket + 'full-build-linux_%s.zip' % rev
 
@@ skipping 329 matching lines @@
   logging.info('Downloading build artifacts for %s', archive.rev)
   # gsutil writes stdout and stderr to stderr, so pipe stdout and stderr to
   # sys.stdout.
   retcode = subprocess.call(
       [gsutil_path, 'cp', build.DownloadUrl(archive.rev), dl_dst],
       stdout=sys.stdout, stderr=subprocess.STDOUT)
   if retcode:
       _Die('unexpected error while downloading %s. It may no longer exist on '
            'the server or it may not have been uploaded yet (check %s). '
            'Otherwise, you may not have the correct access permissions.',
-           build.DownloadUrl(archive.rev), _BUILDER_URL)
+           build.DownloadUrl(archive.rev), build.builder_url)
 
   # Files needed for supersize and resource_sizes. Paths relative to out dir.
   to_extract = [build.main_lib_path, build.map_file_path, 'args.gn']
   if build.IsAndroid():
     to_extract += ['build_vars.txt', build.apk_path, build.apk_path + '.size']
   extract_dir = dl_dst + '_' + 'unzipped'
   # Storage bucket stores entire output directory including out/Release prefix.
   logging.info('Extracting build artifacts')
   with zipfile.ZipFile(dl_dst, 'r') as z:
     _ExtractFiles(to_extract, build.download_output_dir, extract_dir, z)
@@ skipping 42 matching lines @@
     shutil.rmtree(tmp_dir)
 
 
 def _SetRestoreFunc(subrepo):
   branch = _GitCmd(['rev-parse', '--abbrev-ref', 'HEAD'], subrepo)
   atexit.register(lambda: _GitCmd(['checkout', branch], subrepo))
 
 
 def main():
   parser = argparse.ArgumentParser(
-      description='Find the cause of APK size bloat.')
+      description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
   parser.add_argument('--archive-directory',
                       default=_DEFAULT_ARCHIVE_DIR,
                       help='Where results are stored.')
   parser.add_argument('rev',
                       help='Find binary size bloat for this commit.')
   parser.add_argument('--reference-rev',
                       help='Older rev to diff against. If not supplied, '
-                      'the previous commit to rev will be used.')
+                           'the previous commit to rev will be used.')
   parser.add_argument('--all',
                       action='store_true',
                       help='Build/download all revs from --reference-rev to '
-                      'rev and diff the contiguous revisions.')
+                           'rev and diff the contiguous revisions.')
   parser.add_argument('--include-slow-options',
                       action='store_true',
                       help='Run some extra steps that take longer to complete. '
-                      'This includes apk-patch-size estimation and '
-                      'static-initializer counting.')
+                           'This includes apk-patch-size estimation and '
+                           'static-initializer counting.')
   parser.add_argument('--cloud',
                       action='store_true',
                       help='Download build artifacts from perf builders '
-                      '(Android only, Googlers only).')
+                      '(Googlers only).')
   parser.add_argument('--depot-tools-path',
                       help='Custom path to depot tools. Needed for --cloud if '
-                      'depot tools isn\'t in your PATH.')
+                           'depot tools isn\'t in your PATH.')
   parser.add_argument('--subrepo',
                       help='Specify a subrepo directory to use. Gclient sync '
-                      'will be skipped if this option is used and all git '
-                      'commands will be executed from the subrepo directory. '
-                      'This option doesn\'t work with --cloud.')
-  parser.add_argument('--silent',
+                           'will be skipped if this option is used and all git '
+                           'commands will be executed from the subrepo '
+                           'directory. This option doesn\'t work with --cloud.')
+  parser.add_argument('-v',
+                      '--verbose',
                       action='store_true',
-                      help='Less logging, no Ninja/GN output.')
+                      help='Show  commands executed, extra debugging output'
+                           ', and Ninja/GN output')
 
-  build_group = parser.add_argument_group('ninja', 'Args to use with ninja/gn')
+  build_group = parser.add_argument_group('ninja arguments')
   build_group.add_argument('-j',
                            dest='max_jobs',
                            help='Run N jobs in parallel.')
   build_group.add_argument('-l',
                            dest='max_load_average',
                            help='Do not start new jobs if the load average is '
                            'greater than N.')
   build_group.add_argument('--no-goma',
                            action='store_false',
                            dest='use_goma',
                            default=True,
                            help='Do not use goma when building with ninja.')
   build_group.add_argument('--target-os',
                            default='android',
                            choices=['android', 'linux'],
                            help='target_os gn arg. Default: android.')
   build_group.add_argument('--output-directory',
                            default=_DEFAULT_OUT_DIR,
                            help='ninja output directory. '
-                           'Default: %s.' % _DEFAULT_OUT_DIR)
+                                'Default: %s.' % _DEFAULT_OUT_DIR)
   build_group.add_argument('--enable-chrome-android-internal',
                            action='store_true',
                            help='Allow downstream targets to be built.')
   build_group.add_argument('--target',
                            default=_DEFAULT_ANDROID_TARGET,
                            help='GN APK target to build. Ignored for Linux. '
-                           'Default %s.' % _DEFAULT_ANDROID_TARGET)
+                                'Default %s.' % _DEFAULT_ANDROID_TARGET)
   if len(sys.argv) == 1:
     parser.print_help()
     sys.exit()
   args = parser.parse_args()
-  log_level = logging.INFO if args.silent else logging.DEBUG
+  log_level = logging.DEBUG if args.verbose else logging.INFO
   logging.basicConfig(level=log_level,
                       format='%(levelname).1s %(relativeCreated)6d %(message)s')
   build = _BuildHelper(args)
   if build.IsCloud() and args.subrepo:
       parser.error('--subrepo doesn\'t work with --cloud')
 
   subrepo = args.subrepo or _SRC_ROOT
   _EnsureDirectoryClean(subrepo)
   _SetRestoreFunc(subrepo)
   if build.IsLinux():
-    _VerifyUserAccepts('Linux diffs have known deficiencies (crbug/717550).')
+    _VerifyUserAccepts('Linux diffs have known deficiencies (crbug/717550). ')
 
   rev, reference_rev = _ValidateRevs(
       args.rev, args.reference_rev or args.rev + '^', subrepo)
   revs = _GenerateRevList(rev, reference_rev, args.all, subrepo)
   with _TmpCopyBinarySizeDir() as supersize_path:
     diffs = [NativeDiff(build.size_name, supersize_path)]
     if build.IsAndroid():
       diffs +=  [
           ResourceSizesDiff(
               build.apk_name, slow_options=args.include_slow_options)
@@ skipping 26 matching lines @@
 
       if i != 0:
         diff_mngr.MaybeDiff(i - 1, i)
 
     diff_mngr.Summarize()
 
 
 if __name__ == '__main__':
   sys.exit(main())