Fix the stack script issue when symbolizing tombstones.

build/android/tombstones.py

 #!/usr/bin/env python
 #
 # Copyright 2013 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.
 #
 # Find the most recent tombstone file(s) on all connected devices
 # and prints their stacks.
 #
 # Assumes tombstone file was created with current symbols.
@@ skipping 114 matching lines @@
       device_abi = found_abi.group(1)
   arch = _DeviceAbiToArch(device_abi)
   if not arch:
     return
 
   stack_tool = os.path.join(os.path.dirname(__file__), '..', '..',
                             'third_party', 'android_platform', 'development',
                             'scripts', 'stack')
   cmd = [stack_tool, '--arch', arch, '--output-directory',
          constants.GetOutDirectory()]
+  if os.path.exists(os.path.join(constants.GetOutDirectory(), 'lib')):
+    for root, _, files in os.walk(os.path.join(constants.GetOutDirectory(),
+                                               'lib')):
+      for file_name in files:
+        if file_name.endswith('.so'):
+          cmd.extend(['--packed-lib', os.path.join(root, file_name)])

[jbudorick, 2017/07/17 15:50:45]

For symbols, the script will find the lib.unstripped library first, so that's
fine. But this will still *always* indicate to the stack script that packed
relocations need to be accounted for, and that's not the case. I think that
builds that don't use packed relocations would wind up w/ garbled stacks because
of this.

+
   proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
   output = proc.communicate(input='\n'.join(tombstone_data))[0]
   for line in output.split('\n'):
     if not include_stack and 'Stack Data:' in line:
       break
     yield line
 
 
 def _ResolveTombstone(tombstone):
   lines = []
@@ skipping 84 matching lines @@
   """
   all_tombstones = list(_ListTombstones(device))
   if not all_tombstones:
     logging.warning('No tombstones to clear.')
 
   for tombstone_file, _ in all_tombstones:
     _EraseTombstone(device, tombstone_file)
 
 
 def ResolveTombstones(device, resolve_all_tombstones, include_stack_symbols,
-                      wipe_tombstones, jobs=4):
+                      wipe_tombstones, jobs=4, apk_under_test=None):
   """Resolve tombstones in the device.
 
   Args:
     device: An instance of DeviceUtils.
     resolve_all_tombstone: Whether to resolve every tombstone.
     include_stack_symbols: Whether to include symbols for stack data.
     wipe_tombstones: Whether to wipe tombstones.
     jobs: Number of jobs to use when processing multiple crash stacks.
 
   Returns:
     A list of resolved tombstones.
   """
+  if apk_under_test:
+    subprocess.check_call(

[jbudorick, 2017/07/17 16:43:48]

Er, sorry, thought of this after sending the review: we're also going to want to
symbolize other things, not just tombstones (e.g. logcat and possibly stdout).
As such, we should be doing the unzipping outside of tombstones.

+        'unzip -o %s -d %s' % (apk_under_test,

[jbudorick, 2017/07/17 15:50:45]

nit: pass this as a list, i.e.

  ['unzip', ...]

+                               constants.GetOutDirectory()),

[jbudorick, 2017/07/17 15:50:45]

I don't think we should extract this directly into the output directory. A
subdirectory of the output directory would be ok, I suppose. I'd suggest a
temporary directory, but down here in ResolveTombstones, that'd mean that we
unzip *every time* we resolve a tombstone, which is not what we want to do.

+        shell=True)

[jbudorick, 2017/07/17 15:50:45]

This shouldn't need shell features.

+
   return _ResolveTombstones(jobs,
                             _GetTombstonesForDevice(device,
                                                     resolve_all_tombstones,
                                                     include_stack_symbols,
                                                     wipe_tombstones))
 
 
 def main():
   custom_handler = logging.StreamHandler(sys.stdout)
   custom_handler.setFormatter(run_tests_helper.CustomFormatter())
@@ skipping 44 matching lines @@
   for device in devices:
     resolved_tombstones = ResolveTombstones(
         device, args.all_tombstones,
         args.stack, args.wipe_tombstones, args.jobs)
     for line in resolved_tombstones:
       logging.info(line)
 
 
 if __name__ == '__main__':
   sys.exit(main())