Upstreaming latest build/android changes

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 28 matching lines @@
 # Set the adb shell prompt to be a unique marker that will [hopefully] not
 # appear at the start of any line of a command's output.
 SHELL_PROMPT = '~+~PQ\x17RS~+~'
 
 # Java properties file
 LOCAL_PROPERTIES_PATH = '/data/local.prop'
 
 # Property in /data/local.prop that controls Java assertions.
 JAVA_ASSERT_PROPERTY = 'dalvik.vm.enableassertions'
 
-BOOT_COMPLETE_RE = re.compile(
-    'android.intent.action.MEDIA_MOUNTED path: /\w+/sdcard\d?'
-    '|PowerManagerService(\(\s+\d+\))?: bootCompleted')
-
 MEMORY_INFO_RE = re.compile('^(?P<key>\w+):\s+(?P<usage_kb>\d+) kB$')
 NVIDIA_MEMORY_INFO_RE = re.compile('^\s*(?P<user>\S+)\s*(?P<name>\S+)\s*'
                                    '(?P<pid>\d+)\s*(?P<usage_bytes>\d+)$')
 
 # Keycode "enum" suitable for passing to AndroidCommands.SendKey().
 KEYCODE_HOME = 3
 KEYCODE_BACK = 4
 KEYCODE_DPAD_UP = 19
 KEYCODE_DPAD_DOWN = 20
 KEYCODE_DPAD_RIGHT = 22
@@ skipping 214 matching lines @@
     # connection; work out if we can handle this better
     if os.environ.get('USING_HIVE'):
       logging.warning('Ignoring reboot request as we are on hive')
       return
     if full_reboot or not self.IsRootEnabled():
       self._adb.SendCommand('reboot')
       timeout = 300
     else:
       self.RestartShell()
       timeout = 120
+    # To run tests we need at least the package manager and the sd card (or
+    # other external storage) to be ready.
     self.WaitForDevicePm()
-    self.StartMonitoringLogcat(timeout=timeout)
-    self.WaitForLogMatch(BOOT_COMPLETE_RE, None)
+    self.WaitForSdCardReady(timeout)
 
   def Uninstall(self, package):
     """Uninstalls the specified package from the device.
 
     Args:
       package: Name of the package to remove.
 
     Returns:
       A status string returned by adb uninstall
     """
@@ skipping 212 matching lines @@
         elif isinstance(value, int):
           cmd += ' --ei'
         else:
           raise NotImplementedError(
               'Need to teach StartActivity how to pass %s extras' % type(value))
         cmd += ' %s %s' % (key, value)
     if trace_file_name:
       cmd += ' --start-profiler ' + trace_file_name
     self.RunShellCommand(cmd)
 
+  def GoHome(self):
+    """Tell the device to return to the home screen. Blocks until completion."""
+    self.RunShellCommand('am start -W '
+        '-a android.intent.action.MAIN -c android.intent.category.HOME')
+
   def CloseApplication(self, package):
     """Attempt to close down the application, using increasing violence.
 
     Args:
       package: Name of the process to kill off, e.g.
       com.google.android.apps.chrome
     """
     self.RunShellCommand('am force-stop ' + package)
 
   def ClearApplicationState(self, package):
@@ skipping 128 matching lines @@
     # Next, check the current runtime value is what we need, and
     # if not, set it and report that a reboot is required.
     was_set = 'all' in self.RunShellCommand('getprop ' + JAVA_ASSERT_PROPERTY)
     if was_set == enable:
       return False
 
     self.RunShellCommand('setprop %s "%s"' % (JAVA_ASSERT_PROPERTY,
                                               enable and 'all' or ''))
     return True
 
+  def GetBuildId(self):
+    """Returns the build ID of the system (e.g. JRM79C)."""
+    build_id = self.RunShellCommand('getprop ro.build.id')[0]
+    assert build_id
+    return build_id
+
+  def GetBuildType(self):
+    """Returns the build type of the system (e.g. eng)."""
+    build_type = self.RunShellCommand('getprop ro.build.type')[0]
+    assert build_type
+    return build_type
 
   def StartMonitoringLogcat(self, clear=True, timeout=10, logfile=None,
                             filters=None):
     """Starts monitoring the output of logcat, for use with WaitForLogMatch.
 
     Args:
       clear: If True the existing logcat output will be cleared, to avoiding
              matching historical output lurking in the log.
       timeout: How long WaitForLogMatch will wait for the given match
       filters: A list of logcat filters to be used.
@@ skipping 41 matching lines @@
       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.
     """
-    if not self._logcat:
-      self.StartMonitoringLogcat(clear)
     logging.info('<<< Waiting for logcat:' + str(success_re.pattern))
     t0 = time.time()
-    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)
-          if error_match:
-            return None
-        success_match = success_re.search(line)
-        if success_match:
-          return success_match
-        logging.info('<<< Skipped Logcat Line:' + str(line))
-    except pexpect.TIMEOUT:
-      raise pexpect.TIMEOUT(
-          'Timeout (%ds) exceeded waiting for pattern "%s" (tip: use -vv '
-          'to debug)' %
-          (self._logcat.timeout, success_re.pattern))
+    while True:
+      if not self._logcat:
+        self.StartMonitoringLogcat(clear)
+      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)
+            if error_match:
+              return None
+          success_match = success_re.search(line)
+          if success_match:
+            return success_match
+          logging.info('<<< Skipped Logcat Line:' + str(line))
+      except pexpect.TIMEOUT:
+        raise pexpect.TIMEOUT(
+            'Timeout (%ds) exceeded waiting for pattern "%s" (tip: use -vv '
+            'to debug)' %
+            (self._logcat.timeout, success_re.pattern))
+      except pexpect.EOF:
+        # It seems that sometimes logcat can end unexpectedly. This seems
+        # to happen during Chrome startup after a reboot followed by a cache
+        # clean. I don't understand why this happens, but this code deals with
+        # getting EOF in logcat.
+        logging.critical('Found EOF in adb logcat. Restarting...')
+        # Rerun spawn with original arguments. Note that self._logcat.args[0] is
+        # the path of adb, so we don't want it in the arguments.
+        self._logcat = pexpect.spawn('adb',
+                                     self._logcat.args[1:],
+                                     timeout=self._logcat.timeout,
+                                     logfile=self._logcat.logfile)
 
   def StartRecordingLogcat(self, clear=True, filters=['*:v']):
     """Starts recording logcat output to eventually be saved as a string.
 
     This call should come before some series of tests are run, with either
     StopRecordingLogcat or SearchLogcatRecord following the tests.
 
     Args:
       clear: True if existing log output should be cleared.
       filters: A list of logcat filters to be used.
@@ skipping 244 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()
+