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_FMT = 'temp_file_%d'
+  _TEMP_SCRIPT_FILE_BASE_FMT = 'temp_script_file_%d.sh'
+
+  def _GetDeviceTempFileName(self, base_name):
+    i = 0
+    while self.FileExistsOnDevice(
+        self.GetExternalStorage() + '/' + base_name % i):
+      i += 1
+    return self.GetExternalStorage() + '/' + base_name % i
+
+  def SetProtectedFileContents(self, filename, contents):
+    """Writes |contents| to the protected file specified by |filename|.
+
+    This is less efficient than SetFileContents, but will work for protected
+    files and device files.
+    """
+    temp_file = self._GetDeviceTempFileName(AndroidCommands._TEMP_FILE_BASE_FMT)
+    temp_script = self._GetDeviceTempFileName(
+        AndroidCommands._TEMP_SCRIPT_FILE_BASE_FMT)
+
+    # 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 95 matching lines @@
     else:
       logging.critical('Error reading from logcat: ' + str(self._logcat.match))
       sys.exit(1)
 
   def GetMonitoredLogCat(self):
     """Returns an "adb logcat" command as created by pexpected.spawn."""
     if not self._logcat:
       self.StartMonitoringLogcat(clear=False)
     return self._logcat
 
-  def WaitForLogMatch(self, success_re, error_re, clear=False):
+  def WaitForLogMatch(self, success_re, error_re, clear=False, timeout=10):
     """Blocks until a matching line is logged or a timeout occurs.
 
     Args:
       success_re: A compiled re to search each line for.
       error_re: A compiled re which, if found, terminates the search for
           |success_re|. If None is given, no error condition will be detected.
       clear: If True the existing logcat output will be cleared, defaults to
           false.
 
     Raises:
       pexpect.TIMEOUT upon the timeout specified by StartMonitoringLogcat().
 
     Returns:
       The re match object if |success_re| is matched first or None if |error_re|
       is matched first.
     """
     logging.info('<<< Waiting for logcat:' + str(success_re.pattern))
     t0 = time.time()
     while True:
       if not self._logcat:
-        self.StartMonitoringLogcat(clear)
+        self.StartMonitoringLogcat(clear, timeout=timeout)
       try:
         while True:
           # Note this will block for upto the timeout _per log line_, so we need
           # to calculate the overall timeout remaining since t0.
           time_remaining = t0 + self._logcat.timeout - time.time()
           if time_remaining < 0: raise pexpect.TIMEOUT(self._logcat)
           self._logcat.expect(PEXPECT_LINE_RE, timeout=time_remaining)
           line = self._logcat.match.group(1)
           if error_re:
             error_match = error_re.search(line)
@@ skipping 297 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()