Revert of [Android] Remove android_commands and android_testrunner.

tools/cygprofile/profile_android_startup.py

 # Copyright (c) 2015 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.
 
 """Utility library for running a startup profile on an Android device.
 
 Sets up a device for cygprofile, disables sandboxing permissions, and sets up
 support for web page replay, device forwarding, and fake certificate authority
 to make runs repeatable.
 """
@@ skipping 200 matching lines @@
   def RunCygprofileTests(self):
     """Run the cygprofile unit tests suite on the device.
 
     Args:
       path_to_tests: The location on the host machine with the compiled
                      cygprofile test binary.
     Returns:
       The exit code for the tests.
     """
     device_path = '/data/local/tmp/cygprofile_unittests'
-    self._device.PushChangedFiles([(self._cygprofile_tests, device_path)])
-    try:
-      self._device.RunShellCommand(device_path, check_return=True)
-    except device_errors.CommandFailedError:
-      # TODO(jbudorick): Let the exception propagate up once clients can
-      # handle it.
-      logging.exception('Failure while running cygprofile_unittests:')
-      return 1
-    return 0
+    self._device.old_interface.PushIfNeeded(
+        self._cygprofile_tests, device_path)
+    (exit_code, _) = (
+        self._device.old_interface.GetShellCommandStatusAndOutput(
+            command=device_path, log_result=True))
+    return exit_code
 
   def CollectProfile(self, apk, package_info):
     """Run a profile and collect the log files.
 
     Args:
       apk: The location of the chrome apk to profile.
       package_info: A PackageInfo structure describing the chrome apk,
                     as from pylib/constants.
     Returns:
       A list of cygprofile data files.
     Raises:
       NoCyglogDataError: No data was found on the device.
     """
-    self._Install(apk)
+    self._Install(apk, package_info)
+
     try:
       changer = self._SetChromeFlags(package_info)
       self._SetUpDeviceFolders()
       # Start up chrome once with a blank page, just to get the one-off
       # activities out of the way such as apk resource extraction and profile
       # creation.
       self._StartChrome(package_info, 'about:blank')
       time.sleep(15)
       self._KillChrome(package_info)
       self._SetUpDeviceFolders()
       with WprManager(self._WPR_ARCHIVE, self._device,
                       package_info.cmdline_file):
         self._StartChrome(package_info, self._TEST_URL)
         time.sleep(90)
         self._KillChrome(package_info)
     finally:
       self._RestoreChromeFlags(changer)
 
     data = self._PullCyglogData()
     self._DeleteDeviceData()
     return data
 
   def Cleanup(self):
     """Delete all local and device files left over from profiling. """
     self._DeleteDeviceData()
     self._DeleteHostData()
 
-  def _Install(self, apk):
+  def _Install(self, apk, package_info):
     """Installs Chrome.apk on the device.
     Args:
       apk: The location of the chrome apk to profile.
       package_info: A PackageInfo structure describing the chrome apk,
                     as from pylib/constants.
     """
     print 'Installing apk...'
-    self._device.Install(apk)
+    self._device.old_interface.ManagedInstall(apk, package_info.package)
 
   def _SetUpDevice(self):
     """When profiling, files are output to the disk by every process.  This
     means running without sandboxing enabled.
     """
     # We need to have adb root in order to pull cyglog data
     try:
       print 'Enabling root...'
       self._device.EnableRoot()
       # SELinux need to be in permissive mode, otherwise the process cannot
       # write the log files.
       print 'Putting SELinux in permissive mode...'
-      self._device.RunShellCommand(['setenforce' '0'], check_return=True)
+      self._device.old_interface.RunShellCommand('setenforce 0')
     except device_errors.CommandFailedError as e:
       # TODO(jbudorick) Handle this exception appropriately once interface
       #                 conversions are finished.
       logging.error(str(e))
 
   def _SetChromeFlags(self, package_info):
     print 'Setting Chrome flags...'
     changer = flag_changer.FlagChanger(
         self._device, package_info.cmdline_file)
     changer.AddFlags(['--no-sandbox', '--disable-fre'])
     return changer
 
   def _RestoreChromeFlags(self, changer):
     print 'Restoring Chrome flags...'
     if changer:
       changer.Restore()
 
   def _SetUpDeviceFolders(self):
     """Creates folders on the device to store cyglog data. """
     print 'Setting up device folders...'
     self._DeleteDeviceData()
-    self._device.RunShellCommand(
-        ['mkdir', '-p', str(self._DEVICE_CYGLOG_DIR)],
-        check_return=True)
+    self._device.old_interface.RunShellCommand(
+        'mkdir -p %s' % self._DEVICE_CYGLOG_DIR)
 
   def _DeleteDeviceData(self):
     """Clears out cyglog storage locations on the device. """
-    self._device.RunShellCommand(
-        ['rm', '-rf', str(self._DEVICE_CYGLOG_DIR)],
-        check_return=True)
+    self._device.old_interface.RunShellCommand(
+        'rm -rf %s' % self._DEVICE_CYGLOG_DIR)
 
   def _StartChrome(self, package_info, url):
     print 'Launching chrome...'
     self._device.StartActivity(
         intent.Intent(package=package_info.package,
                       activity=package_info.activity,
                       data=url,
                       extras={'create_new_tab' : True}),
         blocking=True, force_stop=True)
 
@@ skipping 11 matching lines @@
   def _PullCyglogData(self):
     """Pull the cyglog data off of the device.
 
     Returns:
       A list of cyglog data files which were pulled.
     Raises:
       NoCyglogDataError: No data was found on the device.
     """
     print 'Pulling cyglog data...'
     self._SetUpHostFolders()
-    self._device.PullFile(
+    self._device.old_interface.Adb().Pull(
         self._DEVICE_CYGLOG_DIR, self._host_cyglog_dir)
     files = os.listdir(self._host_cyglog_dir)
 
     if len(files) == 0:
       raise NoCyglogDataError('No cyglog data was collected')
 
     return [os.path.join(self._host_cyglog_dir, x) for x in files]