Fix `--verbose` handling in android_shell.

mojo/devtools/common/devtoolslib/android_shell.py

 # Copyright 2014 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.
 
 import atexit
 import hashlib
 import logging
 import os
 import os.path
 import random
@@ skipping 78 matching lines @@
 class AndroidShell(Shell):
   """Wrapper around Mojo shell running on an Android device.
 
   Args:
     adb_path: Path to adb, optional if adb is in PATH.
     target_device: Device to run on, if multiple devices are connected.
     logcat_tags: Comma-separated list of additional logcat tags to use.
   """
 
   def __init__(self, adb_path="adb", target_device=None, logcat_tags=None,
-               verbose_pipe=None):
+               verbose=False):
     self.adb_path = adb_path
     self.target_device = target_device
     self.stop_shell_registered = False
     self.adb_running_as_root = None
     self.additional_logcat_tags = logcat_tags
-    self.verbose_pipe = verbose_pipe if verbose_pipe else open(os.devnull, 'w')
+    self.verbose_stdout = sys.stdout if verbose else open(os.devnull, 'w')
+    self.verbose_stderr = sys.stderr if verbose else open(os.devnull, 'w')

[qsr, 2015/11/12 14:47:37]

sys.stderr if verbose else self.verbose_stdout
This will open one less file.

[ppi, 2015/11/12 14:50:17]

Done.

 
   def _adb_command(self, args):
     """Forms an adb command from the given arguments, prepending the adb path
     and adding a target device specifier, if needed.
     """
     adb_command = [self.adb_path]
     if self.target_device:
       adb_command.extend(['-s', self.target_device])
     adb_command.extend(args)
     return adb_command
@@ skipping 85 matching lines @@
 
   def _run_adb_as_root(self):
     if self.adb_running_as_root is not None:
       return self.adb_running_as_root
 
     if ('cannot run as root' not in subprocess.check_output(
         self._adb_command(['root']))):
       # Wait for adbd to restart.
       subprocess.check_call(
           self._adb_command(['wait-for-device']),
-          stdout=self.verbose_pipe)
+          stdout=self.verbose_stdout, stderr=self.verbose_stderr)
       self.adb_running_as_root = True
     else:
       self.adb_running_as_root = False
 
     return self.adb_running_as_root
 
   def _is_shell_package_installed(self):
     # Adb should print one line if the package is installed and return empty
     # string otherwise.
     return len(subprocess.check_output(self._adb_command([
@@ skipping 68 matching lines @@
     apk_sha1 = hashlib.sha1(open(shell_apk_path, 'rb').read()).hexdigest()
     device_apk_sha1 = subprocess.check_output(self._adb_command([
         'shell', 'cat', device_sha1_path]))
     do_install = (apk_sha1 != device_apk_sha1 or
                   not self._is_shell_package_installed())
 
     if do_install:
       subprocess.check_call(
           self._adb_command(['install', '-r', shell_apk_path, '-i',
                             _MOJO_SHELL_PACKAGE_NAME]),
-          stdout=self.verbose_pipe)
+          stdout=self.verbose_stdout, stderr=self.verbose_stderr)
 
       # Update the stamp on the device.
       with tempfile.NamedTemporaryFile() as fp:
         fp.write(apk_sha1)
         fp.flush()
         subprocess.check_call(self._adb_command(['push', fp.name,
                                                 device_sha1_path]),
-                              stdout=self.verbose_pipe)
+                              stdout=self.verbose_stdout,
+                              stderr=self.verbose_stderr)
     else:
       # To ensure predictable state after running install_apk(), we need to stop
       # the shell here, as this is what "adb install" implicitly does.
       self.stop_shell()
 
   def start_shell(self,
                  arguments,
                  stdout=None,
                  on_application_stop=None):
     """Starts the mojo shell, passing it the given arguments.
@@ skipping 33 matching lines @@
     if parameters:
       device_filename = (
           '/sdcard/%s/args_%s' % (_MOJO_SHELL_PACKAGE_NAME, str(uuid.uuid4())))
       with tempfile.NamedTemporaryFile(delete=False) as temp:
         try:
           for parameter in parameters:
             temp.write(parameter)
             temp.write('\n')
           temp.close()
           subprocess.check_call(self._adb_command(
-              ['push', temp.name, device_filename]))
+              ['push', temp.name, device_filename]),
+              stdout=self.verbose_stdout, stderr=self.verbose_stderr)
         finally:
           os.remove(temp.name)
 
       cmd += ['--es', 'argsFile', device_filename]
 
-    subprocess.check_call(cmd, stdout=self.verbose_pipe)
+    subprocess.check_call(cmd, stdout=self.verbose_stdout,
+                          stderr=self.verbose_stderr)
 
   def stop_shell(self):
     """Stops the mojo shell."""
     subprocess.check_call(self._adb_command(['shell',
                                             'am',
                                             'force-stop',
                                             _MOJO_SHELL_PACKAGE_NAME]))
 
   def clean_logs(self):
     """Cleans the logs on the device."""
@@ skipping 85 matching lines @@
           Results.output = rf.read()
 
     run_thread = threading.Thread(target=do_run)
     run_thread.start()
     run_thread.join(timeout)
 
     if run_thread.is_alive():
       self.stop_shell()
       return None, Results.output, True
     return None, Results.output, False