Revert of 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.
 """
-# pylint: disable-all
 
 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 ImportError:
+except:
   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', signum=signal.SIGTERM, with_su=True)
+      self.KillAll('adbd', signal=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)
 
-  @staticmethod
-  def KillAdbServer():
+  def KillAdbServer(self):
     """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()
     # TODO(b.kelemen): we should really be able to drop the stderr of the
     # command or raise an exception based on what the caller wants.
     result = [ l for l in result if not l.startswith('WARNING') ]
     if ['error: device not found'] == result:
       raise errors.DeviceUnresponsiveError('device not found')
     if log_result:
       self._LogShell('\n'.join(result))
     return result
@@ skipping 10 matching lines @@
     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, signum=9, with_su=False):
+  def KillAll(self, process, signal=9, with_su=False):
     """Android version of killall, connected via adb.
 
     Args:
       process: name of the process to kill off.
-      signum: signal to use, 9 (SIGKILL) by default.
+      signal: 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' % (signum, ' '.join(pids))
+      cmd = 'kill -%d %s' % (signal, ' '.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
 
-  @staticmethod
-  def _GetActivityCommand(package, activity, wait_for_completion, action,
+  def _GetActivityCommand(self, 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):
+  def GetProtectedFileContents(self, filename, log_result=False):
     """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=None):
+  def StartRecordingLogcat(self, clear=True, filters=['*:v']):
     """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
 
-  @staticmethod
-  def SearchLogcatRecord(record, message, thread_id=None, proc_id=None,
+  def SearchLogcatRecord(self, 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):
+    for line in self.GetProtectedFileContents('/proc/%s/smaps' % pid,
+                                              log_result=False):
       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'):
+    for line in self.GetProtectedFileContents('/d/nvmap/generic-0/clients',
+                                              log_result=False):
       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):
+    for line in self.GetProtectedFileContents('/proc/%s/status' % pid,
+                                              log_result=False):
       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()