Enable presubmit pylint in build/android.

build/android/pylib/utils/emulator.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 start and stop Android emulator.
 
 Assumes system environment ANDROID_NDK_ROOT has been set.
 
   Emulator: The class provides the methods to launch/shutdown the emulator with
             the android virtual device named 'avd_armeabi' .
 """
 
 import logging
 import os
-import shutil
 import signal
 import subprocess
-import sys
 import time
 
-import time_profile
 # TODO(craigdh): Move these pylib dependencies to pylib/utils/.
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib import pexpect
+from pylib.utils import time_profile
 
 import errors
 import run_command
 
 # SD card size
 SDCARD_SIZE = '512M'
 
 # Template used to generate config.ini files for the emulator
 CONFIG_TEMPLATE = """avd.ini.encoding=ISO-8859-1
 hw.dPad=no
@@ skipping 54 matching lines @@
   There are odd 'sticky' cases where there can be no emulator process
   running but a device slot is taken.  A little bot trouble and and
   we're out of room forever.
   """
   emulators = android_commands.GetAttachedDevices(hardware=False)
   if not emulators:
     return
   for emu_name in emulators:
     cmd_helper.RunCmd(['adb', '-s', emu_name, 'emu', 'kill'])
   logging.info('Emulator killing is async; give a few seconds for all to die.')
-  for i in range(5):
+  for _ in range(5):
     if not android_commands.GetAttachedDevices(hardware=False):
       return
     time.sleep(1)
 
 
 def DeleteAllTempAVDs():
   """Delete all temporary AVDs which are created for tests.
 
   If the test exits abnormally and some temporary AVDs created when testing may
   be left in the system. Clean these AVDs.
@@ skipping 110 matching lines @@
     android_sdk_root = os.path.join(constants.EMULATOR_SDK_ROOT, 'sdk')
     self.emulator = os.path.join(android_sdk_root, 'tools', 'emulator')
     self.android = os.path.join(android_sdk_root, 'tools', 'android')
     self.popen = None
     self.device = None
     self.abi = abi
     self.avd_name = avd_name
     self.api_level = api_level
     self._CreateAVD()
 
-  def _DeviceName(self):
+  @staticmethod
+  def _DeviceName():
     """Return our device name."""
     port = _GetAvailablePort()
     return ('emulator-%d' % port, port)
 
   def _CreateAVD(self):
     """Creates an AVD with the given name.
 
     Return avd_name.
     """
 
@@ skipping 99 matching lines @@
           # For x86 emulator --enable-kvm will fail early, avoiding accidental
           # runs in a slow mode (i.e. without hardware virtualization support).
           '--enable-kvm',
           ])
 
     logging.info('Emulator launch command: %s', ' '.join(emulator_command))
     self.popen = subprocess.Popen(args=emulator_command,
                                   stderr=subprocess.STDOUT)
     self._InstallKillHandler()
 
-  def _AggressiveImageCleanup(self):
+  @staticmethod
+  def _AggressiveImageCleanup():
     """Aggressive cleanup of emulator images.
 
     Experimentally it looks like our current emulator use on the bot
     leaves image files around in /tmp/android-$USER.  If a "random"
     name gets reused, we choke with a 'File exists' error.
     TODO(jrg): is there a less hacky way to accomplish the same goal?
     """
     logging.info('Aggressive Image Cleanup')
     emulator_imagedir = '/tmp/android-%s' % os.environ['USER']
     if not os.path.exists(emulator_imagedir):
@@ skipping 16 matching lines @@
     number_of_waits = 2  # Make sure we can wfd twice
     adb_cmd = "adb -s %s %s" % (self.device, 'wait-for-device')
     while seconds_waited < self._LAUNCH_TIMEOUT:
       try:
         run_command.RunCommand(adb_cmd,
                                timeout_time=self._WAITFORDEVICE_TIMEOUT,
                                retry_count=1)
         number_of_waits -= 1
         if not number_of_waits:
           break
-      except errors.WaitForResponseTimedOutError as e:
+      except errors.WaitForResponseTimedOutError:
         seconds_waited += self._WAITFORDEVICE_TIMEOUT
         adb_cmd = "adb -s %s %s" % (self.device, 'kill-server')
         run_command.RunCommand(adb_cmd)
       self.popen.poll()
       if self.popen.returncode != None:
         raise EmulatorLaunchException('EMULATOR DIED')
     if seconds_waited >= self._LAUNCH_TIMEOUT:
       raise EmulatorLaunchException('TIMEOUT with wait-for-device')
     logging.info('Seconds waited on wait-for-device: %d', seconds_waited)
     if wait_for_boot:
       # Now that we checked for obvious problems, wait for a boot complete.
       # Waiting for the package manager is sometimes problematic.
       a = android_commands.AndroidCommands(self.device)
       a.WaitForSystemBootCompleted(self._WAITFORBOOT_TIMEOUT)
 
   def Shutdown(self):
     """Shuts down the process started by launch."""
     self._DeleteAVD()
     if self.popen:
       self.popen.poll()
       if self.popen.returncode == None:
         self.popen.kill()
       self.popen = None
 
-  def _ShutdownOnSignal(self, signum, frame):
+  def _ShutdownOnSignal(self, _signum, _frame):
     logging.critical('emulator _ShutdownOnSignal')
     for sig in self._SIGNALS:
       signal.signal(sig, signal.SIG_DFL)
     self.Shutdown()
     raise KeyboardInterrupt  # print a stack
 
   def _InstallKillHandler(self):
     """Install a handler to kill the emulator when we exit unexpectedly."""
     for sig in self._SIGNALS:
       signal.signal(sig, self._ShutdownOnSignal)