Support startup performance tests on Galaxy S3

build/android/pylib/android_commands.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.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 
 import collections
@@ skipping 132 matching lines @@
   files = {}
   for line in ls_output:
     directory_match = re_directory.match(line)
     if directory_match:
       current_dir = directory_match.group('dir')
       continue
     file_match = re_file.match(line)
     if file_match:
       filename = os.path.join(current_dir, file_match.group('filename'))
       if filename.startswith(path_dir):
-        filename = filename[len(path_dir)+1:]
+        filename = filename[len(path_dir) + 1:]
       lastmod = datetime.datetime.strptime(
           file_match.group('date') + ' ' + file_match.group('time')[:5],
           '%Y-%m-%d %H:%M')
       if not utc_offset and 'timezone' in re_file.groupindex:
         utc_offset = file_match.group('timezone')
       if isinstance(utc_offset, str) and len(utc_offset) == 5:
         utc_delta = datetime.timedelta(hours=int(utc_offset[1:3]),
                                        minutes=int(utc_offset[3:5]))
         if utc_offset[0:1] == '-':
           utc_delta = -utc_delta
@@ skipping 55 matching lines @@
     root_test_output = self.RunShellCommand('ls /root') or ['']
     return not 'Permission denied' in root_test_output[0]
 
   def EnableAdbRoot(self):
     """Enables adb root on the device.
 
     Returns:
       True: if output from executing adb root was as expected.
       False: otherwise.
     """
-    return_value = self._adb.EnableAdbRoot()
-    # EnableAdbRoot inserts a call for wait-for-device only when adb logcat
-    # output matches what is expected. Just to be safe add a call to
-    # wait-for-device.
-    self._adb.SendCommand('wait-for-device')
-    return return_value
+    if self.GetBuildType() == 'user':
+      logging.warning("Can't enable root in production builds with type user")
+      return False
+    else:
+      return_value = self._adb.EnableAdbRoot()
+      # EnableAdbRoot inserts a call for wait-for-device only when adb logcat
+      # output matches what is expected. Just to be safe add a call to
+      # wait-for-device.
+      self._adb.SendCommand('wait-for-device')
+      return return_value
 
   def GetDeviceYear(self):
     """Returns the year information of the date on device."""
     return self.RunShellCommand('date +%Y')[0]
 
   def GetExternalStorage(self):
     if not self._external_storage:
       self._external_storage = self.RunShellCommand('echo $EXTERNAL_STORAGE')[0]
       assert self._external_storage, 'Unable to find $EXTERNAL_STORAGE'
     return self._external_storage
@@ skipping 76 matching lines @@
 
     install_cmd = ['install']
 
     if reinstall:
       install_cmd.append('-r')
 
     install_cmd.append(package_file_path)
     install_cmd = ' '.join(install_cmd)
 
     logging.info('>>> $' + install_cmd)
-    return self._adb.SendCommand(install_cmd, timeout_time=2*60, retry_count=0)
+    return self._adb.SendCommand(install_cmd,
+                                 timeout_time=2 * 60,
+                                 retry_count=0)
 
   def ManagedInstall(self, apk_path, keep_data=False, package_name=None,
                      reboots_on_failure=2):
     """Installs specified package and reboots device on timeouts.
 
     Args:
       apk_path: Path to .apk file to install.
       keep_data: Reinstalls instead of uninstalling first, preserving the
         application data.
       package_name: Package name (only needed if keep_data=False).
@@ skipping 287 matching lines @@
     assert os.path.exists(local_path), 'Local path not found %s' % local_path
     hashes_on_host = _ComputeFileListHash(
         subprocess.Popen(
             '%s_host %s' % (self._md5sum_path, local_path),
             stdout=subprocess.PIPE, shell=True).stdout)
     if hashes_on_device == hashes_on_host:
       return
 
     # They don't match, so remove everything first and then create it.
     if os.path.isdir(local_path):
-      self.RunShellCommand('rm -r %s' % device_path, timeout_time=2*60)
+      self.RunShellCommand('rm -r %s' % device_path, timeout_time=2 * 60)
       self.RunShellCommand('mkdir -p %s' % device_path)
 
     # NOTE: We can't use adb_interface.Push() because it hardcodes a timeout of
     # 60 seconds which isn't sufficient for a lot of users of this method.
     push_command = 'push %s %s' % (local_path, device_path)
     logging.info('>>> $' + push_command)
-    output = self._adb.SendCommand(push_command, timeout_time=30*60)
+    output = self._adb.SendCommand(push_command, timeout_time=30 * 60)
     assert _HasAdbPushSucceeded(output)
 
 
   def GetFileContents(self, filename, log_result=False):
     """Gets contents from the file specified by |filename|."""
     return self.RunShellCommand('if [ -f "' + filename + '" ]; then cat "' +
                                 filename + '"; fi', log_result=log_result)
 
   def SetFileContents(self, filename, contents):
     """Writes |contents| to the file specified by |filename|."""
     with tempfile.NamedTemporaryFile() as f:
       f.write(contents)
       f.flush()
       self._adb.Push(f.name, filename)
 
+  _TEMP_FILE_BASE = 'temp_file_%d'
+  _TEMP_SCRIPT_FILE_BASE = 'temp_script_file_%d.sh'
+
+  def _GetDeviceTempFileName(self, base_name):
+    i = 0
+    while self.FileExistsOnDevice(
+        self.GetExternalStorage() + '/' + base_name % i):

[bulach, 2013/01/16 19:11:05]

since base_name is required to be a format and this is an internal method, just
remove the param and use _TEMP_FILE_BASE directly.. also, add a "_FMT" suffix,
the % operation can be ambiguous..

[aberent, 2013/01/17 17:18:06]

Will add format, but can't use _TEMP_FILE_BASE(_FMT) directly without
duplicating code since this is also used with _TEMP_SCRIPT_FILE_BASE(_FMT)

+      i += 1
+    return self.GetExternalStorage() + '/' + base_name % i
+
+  def SetProtectedFileContents(self, filename, contents):
+    """Writes |contents| to the file specified by |filename|.

[bulach, 2013/01/16 19:11:05]

nit: add a \n (python style requires a one-line docstring, then \n, then the
extended documentation.
also, the next lines should be unaligned, the """ needs to be on a line on its
own, see 702-709 below.

[aberent, 2013/01/17 17:18:06]

Done.

+       This is less efficient than SetFileContents, but will
+       work for protected files and device files."""
+    temp_file = self._GetDeviceTempFileName(AndroidCommands._TEMP_FILE_BASE)
+    temp_script = self._GetDeviceTempFileName(
+        AndroidCommands._TEMP_SCRIPT_FILE_BASE)
+
+    # Put the contents in a temporary file
+    self.SetFileContents(temp_file, contents)
+    # Create a script to copy the file contents to its final destination
+    self.SetFileContents(temp_script, 'cat %s > %s' % (temp_file, filename))
+    # Run the script as root
+    self.RunShellCommand('su -c sh %s' % temp_script)
+    # And remove the temporary files
+    self.RunShellCommand('rm ' + temp_file)
+    self.RunShellCommand('rm ' + temp_script)
+
   def RemovePushedFiles(self):
     """Removes all files pushed with PushIfNeeded() from the device."""
     for p in self._pushed_files:
-      self.RunShellCommand('rm -r %s' % p, timeout_time=2*60)
+      self.RunShellCommand('rm -r %s' % p, timeout_time=2 * 60)
 
   def ListPathContents(self, path):
     """Lists files in all subdirectories of |path|.
 
     Args:
       path: The path to list.
 
     Returns:
       A dict of {"name": (size, lastmod), ...}.
     """
@@ skipping 434 matching lines @@
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()