GN Incremental Install: Don't use proguarded dex when is_debug = false

build/android/incremental_install/installer.py

 #!/usr/bin/env python
 #
 # Copyright 2015 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.
 
 """Install *_incremental.apk targets as well as their dependent files."""
 
 import argparse
 import glob
@@ skipping 14 matching lines @@
 from pylib.utils import time_profile
 
 prev_sys_path = list(sys.path)
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir, 'gyp'))
 from util import build_utils
 sys.path = prev_sys_path
 
 
 def _TransformDexPaths(paths):
   """Given paths like ["/a/b/c", "/a/c/d"], returns ["b.c", "c.d"]."""
+  if len(paths) == 1:
+    return [os.path.basename(paths[0])]
+
   prefix_len = len(os.path.commonprefix(paths))
   return [p[prefix_len:].replace(os.sep, '.') for p in paths]
 
 
 def _Execute(concurrently, *funcs):
   """Calls all functions in |funcs| concurrently or in sequence."""
   timer = time_profile.TimeProfile()
   if concurrently:
     reraiser_thread.RunAsync(funcs)
   else:
@@ skipping 11 matching lines @@
 def Uninstall(device, package):
   """Uninstalls and removes all incremental files for the given package."""
   main_timer = time_profile.TimeProfile()
   device.Uninstall(package)
   device.RunShellCommand(['rm', '-rf', _GetDeviceIncrementalDir(package)],
                          check_return=True)
   logging.info('Uninstall took %s seconds.', main_timer.GetDelta())
 
 
 def Install(device, apk, split_globs=None, lib_dir=None, dex_files=None,
-            enable_device_cache=True, use_concurrency=True):
+            enable_device_cache=True, use_concurrency=True,
+            show_proguard_warning=False):
   """Installs the given incremental apk and all required supporting files.
 
   Args:
     device: A DeviceUtils instance.
     apk: The path to the apk, or an ApkHelper instance.
     split_globs: Glob patterns for any required apk splits (optional).
     lib_dir: Directory containing the app's native libraries (optional).
     dex_files: List of .dex.jar files that comprise the app's Dalvik code.
     enable_device_cache: Whether to enable on-device caching of checksums.
     use_concurrency: Whether to speed things up using multiple threads.
+    show_proguard_warning: Whether to print a warning about Proguard not being
+        enabled after installing.
   """
   main_timer = time_profile.TimeProfile()
   install_timer = time_profile.TimeProfile()
   push_native_timer = time_profile.TimeProfile()
   push_dex_timer = time_profile.TimeProfile()
 
   apk = apk_helper.ToHelper(apk)
   apk_package = apk.GetPackageName()
   device_incremental_dir = _GetDeviceIncrementalDir(apk_package)
 
@@ skipping 86 matching lines @@
 
   _Execute(use_concurrency, do_install, do_push_files)
 
   finalize_timer = _Execute(use_concurrency, release_installer_lock, save_cache)
 
   logging.info(
       'Took %s seconds (setup=%s, install=%s, libs=%s, dex=%s, finalize=%s)',
       main_timer.GetDelta(), setup_timer.GetDelta(), install_timer.GetDelta(),
       push_native_timer.GetDelta(), push_dex_timer.GetDelta(),
       finalize_timer.GetDelta())
+  if show_proguard_warning:
+    logging.warning('Target had proguard enabled, but incremental install uses '
+                    'non-proguarded .dex files. Performance characteristics '
+                    'may differ.')
 
 
 def main():
   parser = argparse.ArgumentParser()
   parser.add_argument('apk_path',
                       help='The path to the APK to install.')
   parser.add_argument('--split',
                       action='append',
                       dest='splits',
                       help='A glob matching the apk splits. '
@@ skipping 16 matching lines @@
                       action='store_false',
                       default=True,
                       dest='threading',
                       help='Do not install and push concurrently')
   parser.add_argument('--no-cache',
                       action='store_false',
                       default=True,
                       dest='cache',
                       help='Do not use cached information about what files are '
                            'currently on the target device.')
+  parser.add_argument('--show-proguard-warning',
+                      action='store_true',
+                      default=False,
+                      help='Print a warning about proguard being disabled')
   parser.add_argument('-v',
                       '--verbose',
                       dest='verbose_count',
                       default=0,
                       action='count',
                       help='Verbose level (multiple times for more)')
 
   args = parser.parse_args()
 
   run_tests_helper.SetLogLevel(args.verbose_count)
@@ skipping 22 matching lines @@
       for d, desc in zip(devices, descriptions):
         msg += '  %s (%s)\n' % (d, desc)
       raise Exception(msg)
 
   apk = apk_helper.ToHelper(args.apk_path)
   if args.uninstall:
     Uninstall(device, apk.GetPackageName())
   else:
     Install(device, apk, split_globs=args.splits, lib_dir=args.lib_dir,
             dex_files=args.dex_files, enable_device_cache=args.cache,
-            use_concurrency=args.threading)
+            use_concurrency=args.threading,
+            show_proguard_warning=args.show_proguard_warning)
 
 
 if __name__ == '__main__':
   sys.exit(main())