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 88 matching lines @@
 def _DeviceAbiToArch(device_abi):
   # The order of this list is significant to find the more specific match (e.g.,
   # arm64) before the less specific (e.g., arm).
   arches = ['arm64', 'arm', 'x86_64', 'x86_64', 'x86', 'mips']
   for arch in arches:
     if arch in device_abi:
       return arch
   raise RuntimeError('Unknown device ABI: %s' % device_abi)
 
 
-def _ResolveSymbols(tombstone_data, include_stack, device_abi):
+def _ResolveSymbols(tombstone_data, include_stack, device_abi, packed_libs):
   """Run the stack tool for given tombstone input.
 
   Args:
     tombstone_data: a list of strings of tombstone data.
     include_stack: boolean whether to include stack data in output.
     device_abi: the default ABI of the device which generated the tombstone.
 
   Yields:
     A string for each line of resolved stack output.
   """
   # Check if the tombstone data has an ABI listed, if so use this in preference
   # to the device's default ABI.
   for line in tombstone_data:
     found_abi = re.search('ABI: \'(.+?)\'', line)
     if found_abi:
       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 packed_libs:
+    for packed_lib in packed_libs:
+      cmd.extend(['--packed-lib', packed_lib])
   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):
+def _ResolveTombstone(args):
+  tombstone = args[0]
+  packed_libs = args[1]
   lines = []
   lines += [tombstone['file'] + ' created on ' + str(tombstone['time']) +
             ', about this long ago: ' +
             (str(tombstone['device_now'] - tombstone['time']) +
             ' Device: ' + tombstone['serial'])]
   logging.info('\n'.join(lines))
   logging.info('Resolving...')
   lines += _ResolveSymbols(tombstone['data'], tombstone['stack'],
-                           tombstone['device_abi'])
+                           tombstone['device_abi'],
+                           packed_libs)
   return lines
 
 
-def _ResolveTombstones(jobs, tombstones):
+def _ResolveTombstones(jobs, tombstones, packed_libs):
   """Resolve a list of tombstones.
 
   Args:
     jobs: the number of jobs to use with multiprocess.
     tombstones: a list of tombstones.
   """
   if not tombstones:
     logging.warning('No tombstones to resolve.')
     return []
   if len(tombstones) == 1:
-    data = [_ResolveTombstone(tombstones[0])]
+    data = [_ResolveTombstone([tombstones[0], packed_libs])]
   else:
     pool = multiprocessing.Pool(processes=jobs)
-    data = pool.map(_ResolveTombstone, tombstones)
+    data = pool.map(_ResolveTombstone,
+                    [[tombstone, packed_libs] for tombstone in tombstones])
   resolved_tombstones = []
   for tombstone in data:
     resolved_tombstones.extend(tombstone)
   return resolved_tombstones
 
 
 def _GetTombstonesForDevice(device, resolve_all_tombstones,
                             include_stack_symbols,
                             wipe_tombstones):
   """Returns a list of tombstones on a given device.
@@ skipping 48 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, packed_libs=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.
   """
   return _ResolveTombstones(jobs,
                             _GetTombstonesForDevice(device,
                                                     resolve_all_tombstones,
                                                     include_stack_symbols,
-                                                    wipe_tombstones))
+                                                    wipe_tombstones),
+                            packed_libs)
 
 
 def main():
   custom_handler = logging.StreamHandler(sys.stdout)
   custom_handler.setFormatter(run_tests_helper.CustomFormatter())
   logging.getLogger().addHandler(custom_handler)
   logging.getLogger().setLevel(logging.INFO)
 
   parser = argparse.ArgumentParser()
   parser.add_argument('--device',
@@ skipping 39 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())