Enable presubmit pylint in build/android.

build/android/pylib/android_commands.py

 # Copyright (c) 2012 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.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 
 import collections
 import datetime
 import inspect
 import logging
 import os
 import re
 import shlex
 import signal
 import subprocess
 import sys
 import tempfile
 import time
 
 import cmd_helper
 import constants
 import screenshot
 import system_properties
 
 try:
   from pylib import pexpect
-except:
+except ImportError:
   pexpect = None
 
 sys.path.append(os.path.join(
     constants.DIR_SOURCE_ROOT, 'third_party', 'android_testrunner'))
 import adb_interface
 import am_instrument_parser
 import errors
 
 
 # Pattern to search for the next whole line of pexpect output and capture it
@@ skipping 302 matching lines @@
     retries = 3
     while retries:
       try:
         self._adb.WaitForDevicePm()
         return  # Success
       except errors.WaitForResponseTimedOutError as e:
         last_err = e
         logging.warning('Restarting and retrying after timeout: %s', e)
         retries -= 1
         self.RestartShell()
-    raise last_err  # Only reached after max retries, re-raise the last error.
+    raise last_err # Only reached after max retries, re-raise the last error.
 
   def RestartShell(self):
     """Restarts the shell on the device. Does not block for it to return."""
     self.RunShellCommand('stop')
     self.RunShellCommand('start')
 
   def Reboot(self, full_reboot=True):
     """Reboots the device and waits for the package manager to return.
 
     Args:
@@ skipping 118 matching lines @@
     out = self._adb.SendCommand('remount')
     if out.strip() != 'remount succeeded':
       raise errors.MsgException('Remount failed: %s' % out)
 
   def RestartAdbdOnDevice(self):
     logging.info('Killing adbd on the device...')
     adb_pids = self.ExtractPid('adbd')
     if not adb_pids:
       raise errors.MsgException('Unable to obtain adbd pid')
     try:
-      self.KillAll('adbd', signal=signal.SIGTERM, with_su=True)
+      self.KillAll('adbd', signum=signal.SIGTERM, with_su=True)
       logging.info('Waiting for device to settle...')
       self._adb.SendCommand('wait-for-device')
       new_adb_pids = self.ExtractPid('adbd')
       if new_adb_pids == adb_pids:
         logging.warning('adbd on the device may not have been restarted.')
     except Exception as e:
       logging.error('Exception when trying to kill adbd on the device [%s]', e)
 
   def RestartAdbServer(self):
     """Restart the adb server."""
     ret = self.KillAdbServer()
     if ret != 0:
       raise errors.MsgException('KillAdbServer: %d' % ret)
 
     ret = self.StartAdbServer()
     if ret != 0:
       raise errors.MsgException('StartAdbServer: %d' % ret)
 
-  def KillAdbServer(self):
+  @staticmethod
+  def KillAdbServer():
     """Kill adb server."""
     adb_cmd = [constants.GetAdbPath(), 'kill-server']
     ret = cmd_helper.RunCmd(adb_cmd)
     retry = 0
     while retry < 3:
       ret, _ = cmd_helper.GetCmdStatusAndOutput(['pgrep', 'adb'])
       if ret != 0:
         # pgrep didn't find adb, kill-server succeeded.
         return 0
       retry += 1
@@ skipping 109 matching lines @@
       timeout_time: Number of seconds to wait for command to respond before
         retrying, used by AdbInterface.SendShellCommand.
       log_result: Boolean to indicate whether we should log the result of the
                   shell command.
 
     Returns:
       list containing the lines of output received from running the command
     """
     self._CheckCommandIsValid(command)
     self._LogShell(command)
-    if "'" in command: logging.warning(command + " contains ' quotes")
+    if "'" in command:
+      logging.warning(command + " contains ' quotes")
     result = self._adb.SendShellCommand(
         "'%s'" % command, timeout_time).splitlines()
     if ['error: device not found'] == result:
       raise errors.DeviceUnresponsiveError('device not found')
     if log_result:
       self._LogShell('\n'.join(result))
     return result
 
   def GetShellCommandStatusAndOutput(self, command, timeout_time=20,
                                      log_result=False):
     """See RunShellCommand() above.
 
     Returns:
       The tuple (exit code, list of output lines).
     """
     lines = self.RunShellCommand(
         command + '; echo %$?', timeout_time, log_result)
     last_line = lines[-1]
     status_pos = last_line.rfind('%')
     assert status_pos >= 0
     status = int(last_line[status_pos + 1:])
     if status_pos == 0:
       lines = lines[:-1]
     else:
       lines = lines[:-1] + [last_line[:status_pos]]
     return (status, lines)
 
-  def KillAll(self, process, signal=9, with_su=False):
+  def KillAll(self, process, signum=9, with_su=False):
     """Android version of killall, connected via adb.
 
     Args:
       process: name of the process to kill off.
-      signal: signal to use, 9 (SIGKILL) by default.
+      signum: signal to use, 9 (SIGKILL) by default.
       with_su: wether or not to use su to kill the processes.
 
     Returns:
       the number of processes killed
     """
     pids = self.ExtractPid(process)
     if pids:
-      cmd = 'kill -%d %s' % (signal, ' '.join(pids))
+      cmd = 'kill -%d %s' % (signum, ' '.join(pids))
       if with_su:
         self.RunShellCommandWithSU(cmd)
       else:
         self.RunShellCommand(cmd)
     return len(pids)
 
   def KillAllBlocking(self, process, timeout_sec):
     """Blocking version of killall, connected via adb.
 
     This waits until no process matching the corresponding name appears in ps'
@@ skipping 11 matching lines @@
       elapsed = 0
       wait_period = 0.1
       # Note that this doesn't take into account the time spent in ExtractPid().
       while self.ExtractPid(process) and elapsed < timeout_sec:
         time.sleep(wait_period)
         elapsed += wait_period
       if elapsed >= timeout_sec:
         return 0
     return processes_killed
 
-  def _GetActivityCommand(self, package, activity, wait_for_completion, action,
+  @staticmethod
+  def _GetActivityCommand(package, activity, wait_for_completion, action,
                           category, data, extras, trace_file_name, force_stop,
                           flags):
     """Creates command to start |package|'s activity on the device.
 
     Args - as for StartActivity
 
     Returns:
       the command to run on the target to start the activity
     """
     cmd = 'am start -a %s' % action
@@ skipping 338 matching lines @@
 
   def CanAccessProtectedFileContents(self):
     """Returns True if Get/SetProtectedFileContents would work via "su".
 
     Devices running user builds don't have adb root, but may provide "su" which
     can be used for accessing protected files.
     """
     r = self.RunShellCommandWithSU('cat /dev/null')
     return r == [] or r[0].strip() == ''
 
-  def GetProtectedFileContents(self, filename, log_result=False):
+  def GetProtectedFileContents(self, filename):
     """Gets contents from the protected file specified by |filename|.
 
     This is less efficient than GetFileContents, but will work for protected
     files and device files.
     """
     # Run the script as root
     return self.RunShellCommandWithSU('cat "%s" 2> /dev/null' % filename)
 
   def SetProtectedFileContents(self, filename, contents):
     """Writes |contents| to the protected file specified by |filename|.
@@ skipping 227 matching lines @@
     logging.info('<<< Waiting for logcat:' + str(success_re.pattern))
     t0 = time.time()
     while True:
       if not self._logcat:
         self.StartMonitoringLogcat(clear)
       try:
         while True:
           # Note this will block for upto the timeout _per log line_, so we need
           # to calculate the overall timeout remaining since t0.
           time_remaining = t0 + timeout - time.time()
-          if time_remaining < 0: raise pexpect.TIMEOUT(self._logcat)
+          if time_remaining < 0:
+            raise pexpect.TIMEOUT(self._logcat)
           self._logcat.expect(PEXPECT_LINE_RE, timeout=time_remaining)
           line = self._logcat.match.group(1)
           if error_re:
             error_match = error_re.search(line)
             if error_match:
               return None
           success_match = success_re.search(line)
           if success_match:
             return success_match
           logging.info('<<< Skipped Logcat Line:' + str(line))
       except pexpect.TIMEOUT:
         raise pexpect.TIMEOUT(
             'Timeout (%ds) exceeded waiting for pattern "%s" (tip: use -vv '
             'to debug)' %
             (timeout, success_re.pattern))
       except pexpect.EOF:
         # It seems that sometimes logcat can end unexpectedly. This seems
         # to happen during Chrome startup after a reboot followed by a cache
         # clean. I don't understand why this happens, but this code deals with
         # getting EOF in logcat.
         logging.critical('Found EOF in adb logcat. Restarting...')
         # Rerun spawn with original arguments. Note that self._logcat.args[0] is
         # the path of adb, so we don't want it in the arguments.
         self._logcat = pexpect.spawn(constants.GetAdbPath(),
                                      self._logcat.args[1:],
                                      timeout=self._logcat.timeout,
                                      logfile=self._logcat.logfile)
 
-  def StartRecordingLogcat(self, clear=True, filters=['*:v']):
+  def StartRecordingLogcat(self, clear=True, filters=None):
     """Starts recording logcat output to eventually be saved as a string.
 
     This call should come before some series of tests are run, with either
     StopRecordingLogcat or SearchLogcatRecord following the tests.
 
     Args:
       clear: True if existing log output should be cleared.
       filters: A list of logcat filters to be used.
     """
+    if not filters:
+      filters = ['*:v']
     if clear:
       self._adb.SendCommand('logcat -c')
     logcat_command = 'adb %s logcat -v threadtime %s' % (self._adb._target_arg,
                                                          ' '.join(filters))
     self._logcat_tmpoutfile = tempfile.NamedTemporaryFile(bufsize=0)
     self.logcat_process = subprocess.Popen(logcat_command, shell=True,
                                            stdout=self._logcat_tmpoutfile)
 
   def GetCurrentRecordedLogcat(self):
     """Return the current content of the logcat being recorded.
@@ skipping 24 matching lines @@
     if self.logcat_process.poll() is None:
       self.logcat_process.kill()
     self.logcat_process.wait()
     self.logcat_process = None
     self._logcat_tmpoutfile.seek(0)
     output = self._logcat_tmpoutfile.read()
     self._logcat_tmpoutfile.close()
     self._logcat_tmpoutfile = None
     return output
 
-  def SearchLogcatRecord(self, record, message, thread_id=None, proc_id=None,
+  @staticmethod
+  def SearchLogcatRecord(record, message, thread_id=None, proc_id=None,
                          log_level=None, component=None):
     """Searches the specified logcat output and returns results.
 
     This method searches through the logcat output specified by record for a
     certain message, narrowing results by matching them against any other
     specified criteria.  It returns all matching lines as described below.
 
     Args:
       record: A string generated by Start/StopRecordingLogcat to search.
       message: An output string to search for.
@@ skipping 95 matching lines @@
       A tuple containg:
       [0]: Dict of {metric:usage_kb}, for the process which has specified pid.
       The metric keys which may be included are: Size, Rss, Pss, Shared_Clean,
       Shared_Dirty, Private_Clean, Private_Dirty, Referenced, Swap,
       KernelPageSize, MMUPageSize, Nvidia (tablet only), VmHWM.
       [1]: Detailed /proc/[PID]/smaps information.
     """
     usage_dict = collections.defaultdict(int)
     smaps = collections.defaultdict(dict)
     current_smap = ''
-    for line in self.GetProtectedFileContents('/proc/%s/smaps' % pid,
-                                              log_result=False):
+    for line in self.GetProtectedFileContents('/proc/%s/smaps' % pid):
       items = line.split()
       # See man 5 proc for more details. The format is:
       # address perms offset dev inode pathname
       if len(items) > 5:
         current_smap = ' '.join(items[5:])
       elif len(items) > 3:
         current_smap = ' '.join(items[3:])
       match = re.match(MEMORY_INFO_RE, line)
       if match:
         key = match.group('key')
         usage_kb = int(match.group('usage_kb'))
         usage_dict[key] += usage_kb
         if key not in smaps[current_smap]:
           smaps[current_smap][key] = 0
         smaps[current_smap][key] += usage_kb
     if not usage_dict or not any(usage_dict.values()):
       # Presumably the process died between ps and calling this method.
       logging.warning('Could not find memory usage for pid ' + str(pid))
 
-    for line in self.GetProtectedFileContents('/d/nvmap/generic-0/clients',
-                                              log_result=False):
+    for line in self.GetProtectedFileContents('/d/nvmap/generic-0/clients'):
       match = re.match(NVIDIA_MEMORY_INFO_RE, line)
       if match and match.group('pid') == pid:
         usage_bytes = int(match.group('usage_bytes'))
         usage_dict['Nvidia'] = int(round(usage_bytes / 1000.0))  # kB
         break
 
     peak_value_kb = 0
-    for line in self.GetProtectedFileContents('/proc/%s/status' % pid,
-                                              log_result=False):
+    for line in self.GetProtectedFileContents('/proc/%s/status' % pid):
       if not line.startswith('VmHWM:'):  # Format: 'VmHWM: +[0-9]+ kB'
         continue
       peak_value_kb = int(line.split(':')[1].strip().split(' ')[0])
     usage_dict['VmHWM'] = peak_value_kb
     if not peak_value_kb:
       logging.warning('Could not find memory peak value for pid ' + str(pid))
 
     return (usage_dict, smaps)
 
   def GetMemoryUsageForPackage(self, package):
@@ skipping 222 matching lines @@
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()