Enable presubmit pylint in build/android.

build/android/pylib/valgrind_tools.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.
 
 """
 Classes in this file define additional actions that need to be taken to run a
 test under some kind of runtime error detection tool.
 
 The interface is intended to be used as follows.
 
 1. For tests that simply run a native process (i.e. no activity is spawned):
 
 Call tool.CopyFiles().
 Prepend test command line with tool.GetTestWrapper().
 
 2. For tests that spawn an activity:
 
 Call tool.CopyFiles().
 Call tool.SetupEnvironment().
 Run the test as usual.
 Call tool.CleanUpEnvironment().
 """
+# pylint: disable=R0201
 
 import os.path
 import sys
 from glob import glob
 
-from constants import DIR_SOURCE_ROOT
+from pylib.constants import DIR_SOURCE_ROOT
 
 
 def SetChromeTimeoutScale(adb, scale):
   """Sets the timeout scale in /data/local/tmp/chrome_timeout_scale to scale."""
   path = '/data/local/tmp/chrome_timeout_scale'
   if not scale or scale == 1.0:
     # Delete if scale is None/0.0/1.0 since the default timeout scale is 1.0
     adb.RunShellCommand('rm %s' % path)
   else:
     adb.SetProtectedFileContents(path, '%f' % scale)
 
 
 class BaseTool(object):
   """A tool that does nothing."""
 
+  def __init__(self):
+    """Does nothing."""
+    pass
+
   def GetTestWrapper(self):
     """Returns a string that is to be prepended to the test command line."""
     return ''
 
   def GetUtilWrapper(self):
     """Returns the wrapper name for the utilities.
 
     Returns:
        A string that is to be prepended to the command line of utility
     processes (forwarder, etc.).
@@ skipping 28 matching lines @@
     return False
 
 
 class AddressSanitizerTool(BaseTool):
   """AddressSanitizer tool."""
 
   TMP_DIR = '/data/local/tmp/asan'
   WRAPPER_NAME = 'asanwrapper.sh'
 
   def __init__(self, adb):
+    super(AddressSanitizerTool, self).__init__()
     self._adb = adb
     self._wrap_properties = ['wrap.com.google.android.apps.ch',
                              'wrap.org.chromium.native_test',
                              'wrap.org.chromium.content_shell',
                              'wrap.org.chromium.chrome.testsh',
                              'wrap.org.chromium.android_webvi']
     # Configure AndroidCommands to run utils (such as md5sum_bin) under ASan.
     # This is required because ASan is a compiler-based tool, and md5sum
     # includes instrumented code from base.
     adb.SetUtilWrapper(self.GetUtilWrapper())
@@ skipping 38 matching lines @@
     return 20.0
 
 
 class ValgrindTool(BaseTool):
   """Base abstract class for Valgrind tools."""
 
   VG_DIR = '/data/local/tmp/valgrind'
   VGLOGS_DIR = '/data/local/tmp/vglogs'
 
   def __init__(self, adb):
+    super(ValgrindTool, self).__init__()
     self._adb = adb
     # exactly 31 chars, SystemProperties::PROP_NAME_MAX
     self._wrap_properties = ['wrap.com.google.android.apps.ch',
                              'wrap.org.chromium.native_test']
 
   def CopyFiles(self):
     """Copies Valgrind tools to the device."""
     self._adb.RunShellCommand('rm -r %s; mkdir %s' %
                               (ValgrindTool.VG_DIR, ValgrindTool.VG_DIR))
     self._adb.RunShellCommand('rm -r %s; mkdir %s' %
@@ skipping 70 matching lines @@
   def GetTestWrapper(self):
     """Returns a string that is to be prepended to the test command line."""
     return ValgrindTool.VG_DIR + '/' + 'vg-chrome-wrapper-tsan.sh'
 
   def GetTimeoutScale(self):
     """Returns a multiplier that should be applied to timeout values."""
     return 30.0
 
 
 TOOL_REGISTRY = {
-    'memcheck': lambda x: MemcheckTool(x),
-    'memcheck-renderer': lambda x: MemcheckTool(x),
-    'tsan': lambda x: TSanTool(x),
-    'tsan-renderer': lambda x: TSanTool(x),
-    'asan': lambda x: AddressSanitizerTool(x),
+    'memcheck': MemcheckTool,
+    'memcheck-renderer': MemcheckTool,
+    'tsan': TSanTool,
+    'tsan-renderer': TSanTool,
+    'asan': AddressSanitizerTool,
 }
 
 
 def CreateTool(tool_name, adb):
   """Creates a tool with the specified tool name.
 
   Args:
     tool_name: Name of the tool to create.
     adb: ADB interface the tool will use.
   Returns:
     A tool for the specified tool_name.
   """
   if not tool_name:
     return BaseTool()
 
   ctor = TOOL_REGISTRY.get(tool_name)
   if ctor:
     return ctor(adb)
   else:
     print 'Unknown tool %s, available tools: %s' % (
         tool_name, ', '.join(sorted(TOOL_REGISTRY.keys())))
     sys.exit(1)