Enable presubmit pylint in build/android.

build/android/pylib/forwarder.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.
 
 import fcntl
 import logging
 import os
 import psutil
-import re
-import sys
-import time
 
-import android_commands
-import cmd_helper
-import constants
-
-from pylib import valgrind_tools
+from . import cmd_helper
+from . import constants
+from . import valgrind_tools
 
 
 def _GetProcessStartTime(pid):
   return psutil.Process(pid).create_time
 
 
 class _FileLock(object):
   """With statement-aware implementation of a file lock.
 
   File locks are needed for cross-process synchronization when the
   multiprocessing Python module is used.
   """
   def __init__(self, path):
+    self._fd = -1
     self._path = path
 
   def __enter__(self):
     self._fd = os.open(self._path, os.O_RDONLY | os.O_CREAT)
     if self._fd < 0:
       raise Exception('Could not open file %s for reading' % self._path)
     fcntl.flock(self._fd, fcntl.LOCK_EX)
 
-  def __exit__(self, type, value, traceback):
+  def __exit__(self, _exception_type, _exception_value, traceback):
     fcntl.flock(self._fd, fcntl.LOCK_UN)
     os.close(self._fd)
 
 
 class Forwarder(object):
   """Thread-safe class to manage port forwards from the device to the host."""
 
   _DEVICE_FORWARDER_FOLDER = (constants.TEST_EXECUTABLE_DIR +
                               '/forwarder/')
   _DEVICE_FORWARDER_PATH = (constants.TEST_EXECUTABLE_DIR +
@@ skipping 97 matching lines @@
       # There are no more ports mapped, kill the device_forwarder.
       tool = valgrind_tools.CreateTool(None, adb)
       Forwarder._KillDeviceLocked(adb, tool)
       Forwarder._instance._initialized_devices.remove(adb_serial)
 
 
   @staticmethod
   def DevicePortForHostPort(host_port):
     """Returns the device port that corresponds to a given host port."""
     with _FileLock(Forwarder._LOCK_PATH):
-      (device_serial, device_port) = Forwarder._GetInstanceLocked(
+      (_device_serial, device_port) = Forwarder._GetInstanceLocked(
           None)._host_to_device_port_map.get(host_port)
       return device_port
 
   @staticmethod
   def RemoveHostLog():
     if os.path.exists(Forwarder._HOST_FORWARDER_LOG):
       os.unlink(Forwarder._HOST_FORWARDER_LOG)
 
   @staticmethod
   def GetHostLog():
@@ skipping 144 matching lines @@
     Note that the global lock must be acquired before calling this method.
 
     Args:
       adb: Instance of AndroidCommands for talking to the device.
       tool: Wrapper tool (e.g. valgrind) that can be used to execute the device
             forwarder (see valgrind_tools.py).
     """
     logging.info('Killing device_forwarder.')
     if not adb.FileExistsOnDevice(Forwarder._DEVICE_FORWARDER_PATH):
       return
-    (exit_code, output) = adb.GetShellCommandStatusAndOutput(
+    adb.GetShellCommandStatusAndOutput(
         '%s %s --kill-server' % (tool.GetUtilWrapper(),
                                  Forwarder._DEVICE_FORWARDER_PATH))
     # TODO(pliard): Remove the following call to KillAllBlocking() when we are
     # sure that the old version of device_forwarder (not supporting
     # 'kill-server') is not running on the bots anymore.
     timeout_sec = 5
     processes_killed = adb.KillAllBlocking('device_forwarder', timeout_sec)
     if not processes_killed:
       pids = adb.ExtractPid('device_forwarder')
       if pids:
         raise Exception('Timed out while killing device_forwarder')