[Android] Remove dedicated presubmit for build/andorid/pylib/symbols/.

build/android/pylib/symbols/elf_symbolizer.py

 # 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.
 
 import collections
 import datetime
 import logging
 import multiprocessing
 import os
 import posixpath
@@ skipping 104 matching lines @@
                                 min(multiprocessing.cpu_count(), 4))
     self.max_queue_size = max_queue_size
     self.addr2line_timeout = addr2line_timeout
     self.requests_counter = 0  # For generating monotonic request IDs.
     self._a2l_instances = []  # Up to |max_concurrent_jobs| _Addr2Line inst.
 
     # If necessary, create disambiguation lookup table
     self.disambiguate = source_root_path is not None
     self.disambiguation_table = {}
     self.strip_base_path = strip_base_path
-    if(self.disambiguate):
+    if self.disambiguate:
       self.source_root_path = os.path.abspath(source_root_path)
       self._CreateDisambiguationTable()
 
     # Create one addr2line instance. More instances will be created on demand
     # (up to |max_concurrent_jobs|) depending on the rate of the requests.
     self._CreateNewA2LInstance()
 
   def SymbolizeAsync(self, addr, callback_arg=None):
     """Requests symbolization of a given address.
 
     This method is not guaranteed to return immediately. It generally does, but
     in some scenarios (e.g. all addr2line instances have full queues) it can
     block to create back-pressure.
 
     Args:
       addr: address to symbolize.
       callback_arg: optional argument which will be passed to the |callback|."""
-    assert(isinstance(addr, int))
+    assert isinstance(addr, int)
 
     # Process all the symbols that have been resolved in the meanwhile.
     # Essentially, this drains all the addr2line(s) out queues.
     for a2l_to_purge in self._a2l_instances:
       a2l_to_purge.ProcessAllResolvedSymbolsInQueue()
       a2l_to_purge.RecycleIfNecessary()
 
     # Find the best instance according to this logic:
     # 1. Find an existing instance with the shortest queue.
     # 2. If all of instances' queues are full, but there is room in the pool,
@@ skipping 17 matching lines @@
 
     a2l.EnqueueRequest(addr, callback_arg)
 
   def Join(self):
     """Waits for all the outstanding requests to complete and terminates."""
     for a2l in self._a2l_instances:
       a2l.WaitForIdle()
       a2l.Terminate()
 
   def _CreateNewA2LInstance(self):
-    assert(len(self._a2l_instances) < self.max_concurrent_jobs)
+    assert len(self._a2l_instances) < self.max_concurrent_jobs
     a2l = ELFSymbolizer.Addr2Line(self)
     self._a2l_instances.append(a2l)
     return a2l
 
   def _CreateDisambiguationTable(self):
     """ Non-unique file names will result in None entries"""
     start_time = time.time()
     logging.info('Collecting information about available source files...')
     self.disambiguation_table = {}
 
@@ skipping 63 matching lines @@
       """Waits for the next pending request to be symbolized."""
       if not self.queue_size:
         return
 
       # This outer loop guards against a2l hanging (detecting stdout timeout).
       while True:
         start_time = datetime.datetime.now()
         timeout = datetime.timedelta(seconds=self._symbolizer.addr2line_timeout)
 
         # The inner loop guards against a2l crashing (checking if it exited).
-        while (datetime.datetime.now() - start_time < timeout):
+        while datetime.datetime.now() - start_time < timeout:
           # poll() returns !None if the process exited. a2l should never exit.
           if self._proc.poll():
-            logging.warning('addr2line crashed, respawning (lib: %s).' %
+            logging.warning('addr2line crashed, respawning (lib: %s).',
                             self._lib_file_name)
             self._RestartAddr2LineProcess()
             # TODO(primiano): the best thing to do in this case would be
             # shrinking the pool size as, very likely, addr2line is crashed
             # due to low memory (and the respawned one will die again soon).
 
           try:
             lines = self._out_queue.get(block=True, timeout=0.25)
           except Queue.Empty:
             # On timeout (1/4 s.) repeat the inner loop and check if either the
             # addr2line process did crash or we waited its output for too long.
             continue
 
           # In nominal conditions, we get straight to this point.
           self._ProcessSymbolOutput(lines)
           return
 
         # If this point is reached, we waited more than |addr2line_timeout|.
-        logging.warning('Hung addr2line process, respawning (lib: %s).' %
+        logging.warning('Hung addr2line process, respawning (lib: %s).',
                         self._lib_file_name)
         self._RestartAddr2LineProcess()
 
     def ProcessAllResolvedSymbolsInQueue(self):
       """Consumes all the addr2line output lines produced (without blocking)."""
       if not self.queue_size:
         return
       while True:
         try:
           lines = self._out_queue.get_nowait()
@@ skipping 10 matching lines @@
         self._RestartAddr2LineProcess()
 
 
     def Terminate(self):
       """Kills the underlying addr2line process.
 
       The poller |_thread| will terminate as well due to the broken pipe."""
       try:
         self._proc.kill()
         self._proc.communicate()  # Essentially wait() without risking deadlock.
-      except Exception:  # An exception while terminating? How interesting.
+      except Exception: # pylint: disable=broad-except
+        # An exception while terminating? How interesting.
         pass
       self._proc = None
 
     def _WriteToA2lStdin(self, addr):
       self._proc.stdin.write('%s\n' % hex(addr))
       if self._symbolizer.inlines:
         # In the case of inlines we output an extra blank line, which causes
         # addr2line to emit a (??,??:0) tuple that we use as a boundary marker.
         self._proc.stdin.write('\n')
       self._proc.stdin.flush()
@@ skipping 10 matching lines @@
         name = line1 if not line1.startswith('?') else None
         source_path = None
         source_line = None
         m = ELFSymbolizer.Addr2Line.SYM_ADDR_RE.match(line2)
         if m:
           if not m.group(1).startswith('?'):
             source_path = m.group(1)
             if not m.group(2).startswith('?'):
               source_line = int(m.group(2))
         else:
-          logging.warning('Got invalid symbol path from addr2line: %s' % line2)
+          logging.warning('Got invalid symbol path from addr2line: %s', line2)
 
         # In case disambiguation is on, and needed
         was_ambiguous = False
         disambiguated = False
         if self._symbolizer.disambiguate:
           if source_path and not posixpath.isabs(source_path):
             path = self._symbolizer.disambiguation_table.get(source_path)
             was_ambiguous = True
             disambiguated = path is not None
             source_path = path if disambiguated else source_path
@@ skipping 98 matching lines @@
     self.source_line = source_line
     # In the case of |inlines|=True, the |inlined_by| points to the outer
     # function inlining the current one (and so on, to form a chain).
     self.inlined_by = None
     self.disambiguated = disambiguated
     self.was_ambiguous = was_ambiguous
 
   def __str__(self):
     return '%s [%s:%d]' % (
         self.name or '??', self.source_path or '??', self.source_line or 0)