[Android] Change object types from AndroidCommands to DeviceUtils 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 23 matching lines @@
 
 """
 # pylint: disable=R0201
 
 import logging
 import os
 import re
 import time
 
 from pylib import constants
-from pylib import android_commands
 from pylib.base import base_test_result
 
 
 ResultType = base_test_result.ResultType
 
 _PACKAGE_NAME = 'org.chromium.chromium_linker_test_apk'
 _ACTIVITY_NAME = '.ChromiumLinkerTestActivity'
 _COMMAND_LINE_FILE = '/data/local/tmp/chromium-linker-test-command-line'
 
 # Path to the Linker.java source file.
@@ skipping 47 matching lines @@
       return None
 
     if configs[0] not in ['NEVER', 'LOW_RAM_ONLY', 'ALWAYS']:
       logging.error('Unexpected browser config value: ' + configs[0])
       return None
 
     logging.info('Found linker browser shared RELRO config: ' + configs[0])
     return configs[0]
 
 
-def _WriteCommandLineFile(adb, command_line, command_line_file):
+def _WriteCommandLineFile(device, command_line, command_line_file):
   """Create a command-line file on the device. This does not use FlagChanger
      because its implementation assumes the device has 'su', and thus does

[craigdh, 2014/04/09 15:55:02]

I believe I fixed FlagChanger a while back so the use of 'su' is optional. This
should be changed to use that.

[jbudorick, 2014/04/09 20:03:33]

The only use of _WriteCommandLineFile attempts to write to _COMMAND_LINE_FILE
(/data/local/tmp/chromium-linker-test-command-line). Since the path starts with
'/data/local/tmp', FlagChanger will attempt to use root permissions.

Even if that weren't the case, I don't think I'd want to make that change in
this CL.

      not work at all with production devices."""
-  adb.RunShellCommand('echo "%s" > %s' % (command_line, command_line_file))
+  device.old_interface.RunShellCommand(
+      'echo "%s" > %s' % (command_line, command_line_file))
 
 
 def _CheckLinkerTestStatus(logcat):
   """Parse the content of |logcat| and checks for both a browser and
      renderer status line.
 
   Args:
     logcat: A string to parse. Can include line separators.
 
   Returns:
@@ skipping 14 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 _StartActivityAndWaitForLinkerTestStatus(adb, timeout):
+def _StartActivityAndWaitForLinkerTestStatus(device, 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|.
+     linker test status lines appear in the logcat, recorded through |device|.
   Args:
-    adb: An AndroidCommands instance.
+    device: A DeviceUtils instance.
     timeout: Timeout in seconds
   Returns:
     A (status, logs) tuple, where status is a ResultType constant, and logs
     if the final logcat output as a string.
   """
   # 1. Start recording logcat with appropriate filters.
-  adb.StartRecordingLogcat(clear=True, filters=_LOGCAT_FILTERS)
+  device.old_interface.StartRecordingLogcat(
+      clear=True, filters=_LOGCAT_FILTERS)
 
   try:
     # 2. Force-start activity.
-    adb.StartActivity(package=_PACKAGE_NAME,
-                      activity=_ACTIVITY_NAME,
-                      force_stop=True)
+    device.old_interface.StartActivity(
+        package=_PACKAGE_NAME, activity=_ACTIVITY_NAME, force_stop=True)
 
     # 3. Wait up to |timeout| seconds until the test status is in the logcat.
     num_tries = 0
     max_tries = timeout
     found = False
     while num_tries < max_tries:
       time.sleep(1)
       num_tries += 1
       found, browser_ok, renderer_ok = _CheckLinkerTestStatus(
-          adb.GetCurrentRecordedLogcat())
+          device.old_interface.GetCurrentRecordedLogcat())
       if found:
         break
 
   finally:
-    logs = adb.StopRecordingLogcat()
+    logs = device.old_interface.StopRecordingLogcat()
 
   if num_tries >= max_tries:
     return ResultType.TIMEOUT, logs
 
   if browser_ok and renderer_ok:
     return ResultType.PASS, logs
 
   return ResultType.FAIL, logs
 
 
@@ skipping 94 matching lines @@
     """
     self.is_low_memory = is_low_memory
     if is_low_memory:
       test_suffix = 'ForLowMemoryDevice'
     else:
       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, _device):
     """Run the test, must be overriden.
     Args:
-      _adb: An AndroidCommands instance to the device.
+      _device: A DeviceUtils interface.
     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:
       device: Name of target device where to run the test.
     Returns:
       A base_test_result.TestRunResult() instance.
     """
     margin = 8
     print '[ %-*s ] %s' % (margin, 'RUN', self.tagged_name)
     logging.info('Running linker test: %s', self.tagged_name)
-    adb = android_commands.AndroidCommands(device)
 
     # Create command-line file on device.
     command_line_flags = ''
     if self.is_low_memory:
       command_line_flags = '--low-memory-device'
-    _WriteCommandLineFile(adb, command_line_flags, _COMMAND_LINE_FILE)
+    _WriteCommandLineFile(device, command_line_flags, _COMMAND_LINE_FILE)
 
     # Run the test.
-    status, logs = self._RunTest(adb)
+    status, logs = self._RunTest(device)
 
     result_text = 'OK'
     if status == ResultType.FAIL:
       result_text = 'FAILED'
     elif status == ResultType.TIMEOUT:
       result_text = 'TIMEOUT'
     print '[ %*s ] %s' % (margin, result_text, self.tagged_name)
 
     results = base_test_result.TestRunResults()
     results.AddResult(
@@ skipping 28 matching lines @@
         where <status> can be either FAIL or SUCCESS. These lines can appear
         in any order in the logcat. Once both browser and renderer status are
         found, stop the loop. Otherwise timeout after 30 seconds.
 
         Note that there can be other lines beginning with BROWSER_LINKER_TEST:
         and RENDERER_LINKER_TEST:, but are not followed by a <status> code.
 
       - The test case passes if the <status> for both the browser and renderer
         process are SUCCESS. Otherwise its a fail.
   """
-  def _RunTest(self, adb):
+  def _RunTest(self, device):
     # Wait up to 30 seconds until the linker test status is in the logcat.
-    return _StartActivityAndWaitForLinkerTestStatus(adb, timeout=30)
+    return _StartActivityAndWaitForLinkerTestStatus(device, timeout=30)
 
 
 class LinkerLibraryAddressTest(LinkerTestCaseBase):
   """A test case that verifies library load addresses.
 
      The point of this check is to ensure that the libraries are loaded
      according to the following rules:
 
      - For low-memory devices, they should always be loaded at the same address
        in both browser and renderer processes, both below 0x4000_0000.
 
      - For regular devices, the browser process should load libraries above
        0x4000_0000, and renderer ones below it.
   """
-  def _RunTest(self, adb):
-    result, logs = _StartActivityAndWaitForLinkerTestStatus(adb, timeout=30)
+  def _RunTest(self, device):
+    result, logs = _StartActivityAndWaitForLinkerTestStatus(device, timeout=30)
 
     # Return immediately in case of timeout.
     if result == ResultType.TIMEOUT:
       return result, logs
 
     # Collect the library load addresses in the browser and renderer processes.
     browser_libs, renderer_libs = _ExtractLibraryLoadAddressesFromLogcat(logs)
 
     logging.info('Browser libraries: %s', browser_libs)
     logging.info('Renderer libraries: %s', renderer_libs)
@@ skipping 65 matching lines @@
 
      This starts the activity several time (each time forcing a new process
      creation) and compares the load addresses of the libraries in them to
      detect that they have changed.
 
      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):
+  def _RunTest(self, device):
     max_loops = 5
     browser_lib_map_list = []
     renderer_lib_map_list = []
     logs_list = []
     for _ in range(max_loops):
       # Start the activity.
-      result, logs = _StartActivityAndWaitForLinkerTestStatus(adb, timeout=30)
+      result, logs = _StartActivityAndWaitForLinkerTestStatus(
+          device, 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)
       logs_list.append(logs)
 
@@ skipping 32 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