Enable presubmit pylint in build/android.

build/android/pylib/linker/test_case.py

 # Copyright 2013 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.
 
 """Base class for linker-specific test cases.
 
    The custom dynamic linker can only be tested through a custom test case
    for various technical reasons:
 
      - It's an 'invisible feature', i.e. it doesn't expose a new API or
@@ skipping 19 matching lines @@
    To build and run the linker tests, do the following:
 
      ninja -C out/Debug content_linker_test_apk
      build/android/test_runner.py linker
 
 """
 
 import logging
 import os
 import re
-import StringIO
-import subprocess
-import tempfile
 import time
 
 from pylib import constants
 from pylib import android_commands
-from pylib import flag_changer
 from pylib.base import base_test_result
 
 ResultType = base_test_result.ResultType
 
-_PACKAGE_NAME='org.chromium.content_linker_test_apk'
-_ACTIVITY_NAME='.ContentLinkerTestActivity'
-_COMMAND_LINE_FILE='/data/local/tmp/content-linker-test-command-line'
+_PACKAGE_NAME = 'org.chromium.content_linker_test_apk'
+_ACTIVITY_NAME = '.ContentLinkerTestActivity'
+_COMMAND_LINE_FILE = '/data/local/tmp/content-linker-test-command-line'
 
 # Path to the Linker.java source file.
-_LINKER_JAVA_SOURCE_PATH = \
-    'content/public/android/java/src/org/chromium/content/app/Linker.java'
+_LINKER_JAVA_SOURCE_PATH = (
+    'content/public/android/java/src/org/chromium/content/app/Linker.java')
 
 # A regular expression used to extract the browser shared RELRO configuration
 # from the Java source file above.
-_RE_LINKER_BROWSER_CONFIG = \
-    re.compile(r'.*BROWSER_SHARED_RELRO_CONFIG\s+=\s+' + \
-               'BROWSER_SHARED_RELRO_CONFIG_(\S+)\s*;.*',
-               re.MULTILINE | re.DOTALL)
+_RE_LINKER_BROWSER_CONFIG = re.compile(
+    r'.*BROWSER_SHARED_RELRO_CONFIG\s+=\s+' +
+        'BROWSER_SHARED_RELRO_CONFIG_(\S+)\s*;.*',
+    re.MULTILINE | re.DOTALL)
 
 # Logcat filters used during each test. Only the 'chromium' one is really
 # needed, but the logs are added to the TestResult in case of error, and
 # it is handy to have the 'content_android_linker' ones as well when
 # troubleshooting.
 _LOGCAT_FILTERS = [ '*:s', 'chromium:v', 'content_android_linker:v' ]
 #_LOGCAT_FILTERS = [ '*:v' ]  ## DEBUG
 
 # Regular expression used to match status lines in logcat.
 re_status_line = re.compile(r'(BROWSER|RENDERER)_LINKER_TEST: (FAIL|SUCCESS)')
@@ skipping 67 matching lines @@
     else:
       assert False, 'Invalid process type ' + process_type
 
   if browser_found and renderer_found:
     return (True, browser_success, renderer_success)
 
   # Didn't find anything.
   return (False, None, None)
 
 
-def _WaitForLinkerTestStatus(adb, timeout):
+def _WaitForLinkerTestStatus(_adb, _timeout):
   """Wait up to |timeout| seconds until the full linker test status lines appear
      in the logcat being recorded with |adb|.
   Args:
     adb: An AndroidCommands instance. This assumes adb.StartRecordingLogcat()
          was called previously.
     timeout: Timeout in seconds.
   Returns:
     ResultType.TIMEOUT in case of timeout, ResulType.PASS if both status lines
     report 'SUCCESS', or ResulType.FAIL otherwise.
   """
+  pass
 
 
 def _StartActivityAndWaitForLinkerTestStatus(adb, timeout):
   """Force-start an activity and wait up to |timeout| seconds until the full
      linker test status lines appear in the logcat, recorded through |adb|.
   Args:
     adb: An AndroidCommands instance.
     timeout: Timeout in seconds
   Returns:
     A (status, logs) tuple, where status is a ResultType constant, and logs
@@ skipping 95 matching lines @@
   for lib_map in lib_map_list:
     for lib_name, lib_address in lib_map.iteritems():
       if lib_name not in lib_addr_map:
         lib_addr_map[lib_name] = AddressList()
       lib_addr_map[lib_name].append(lib_address)
 
   logging.info('%s library load map: %s', process_type, lib_addr_map)
 
   # For each library, check the randomness of its load addresses.
   bad_libs = {}
-  success = True
   for lib_name, lib_address_list in lib_addr_map.iteritems():
     # If all addresses are different, skip to next item.
     lib_address_set = set(lib_address_list)
     # Consider that if there is more than one pair of identical addresses in
     # the list, then randomization is broken.
     if len(lib_address_set) < len(lib_address_list) - 1:
       bad_libs[lib_name] = lib_address_list
 
 
   if bad_libs:
     return False, '%s libraries failed randomization: %s' % \
         (process_type, bad_libs)
 
   return True, '%s libraries properly randomized: %s' % \
       (process_type, lib_addr_map)
 
 
 class LinkerTestCaseBase(object):
   """Base class for linker test cases."""
 
   def __init__(self, is_low_memory=False):
     """Create a test case.
     Args:
       is_low_memory: True to simulate a low-memory device, False otherwise.
     """
     self.is_low_memory = is_low_memory
     if is_low_memory:
-        test_suffix = 'ForLowMemoryDevice'
+      test_suffix = 'ForLowMemoryDevice'
     else:
-        test_suffix = 'ForRegularDevice'
+      test_suffix = 'ForRegularDevice'
     class_name = self.__class__.__name__
     self.qualified_name = '%s.%s' % (class_name, test_suffix)
     self.tagged_name = self.qualified_name
 
-  def _RunTest(self, adb):
+  def _RunTest(self, _adb):
     """Run the test, must be overriden.
     Args:
-      adb: An AndroidCommands instance to the device.
+      _adb: An AndroidCommands instance to the device.
     Returns:
       A (status, log) tuple, where <status> is a ResultType constant, and <log>
       is the logcat output captured during the test in case of error, or None
       in case of success.
     """
     return ResultType.FAIL, 'Unimplemented _RunTest() method!'
 
   def Run(self, device):
     """Run the test on a given device.
     Args:
@@ skipping 164 matching lines @@
      In theory, two successive runs could (very rarely) use the same load
      address, so loop 5 times and compare the values there. It is assumed
      that if there are more than one pair of identical addresses, then the
      load addresses are not random enough for this test.
   """
   def _RunTest(self, adb):
     max_loops = 5
     browser_lib_map_list = []
     renderer_lib_map_list = []
     logs_list = []
-    for loop in range(max_loops):
+    for _loop in range(max_loops):
       # Start the activity.
       result, logs = _StartActivityAndWaitForLinkerTestStatus(adb, timeout=30)
       if result == ResultType.TIMEOUT:
         # Something bad happened. Return immediately.
         return result, logs
 
       # Collect library addresses.
       browser_libs, renderer_libs = _ExtractLibraryLoadAddressesFromLogcat(logs)
       browser_lib_map_list.append(browser_libs)
       renderer_lib_map_list.append(renderer_libs)
@@ skipping 34 matching lines @@
       # Note that this behaviour doesn't seem to happen when starting an
       # application 'normally', i.e. when using the application launcher to
       # start the activity.
       logging.info('Ignoring system\'s low randomization of browser libraries' +
                    ' for regular devices')
 
     if not renderer_status:
       return ResultType.FAIL, renderer_logs
 
     return ResultType.PASS, logs