Unify quoting style in android_shell.py.

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 108 matching lines @@
 
     def _run():
       def _wait_for_fifo():
         for _ in xrange(max_attempts):
           output = subprocess.check_output(fifo_command).strip()
           if output == fifo_path:
             return
           time.sleep(1)
         if on_fifo_closed:
           on_fifo_closed()
-        raise Exception("Unable to find fifo.")
+        raise Exception('Unable to find fifo.')
       _wait_for_fifo()
       stdout_cat = subprocess.Popen(
           self._adb_command(['shell', 'run-as', _MOJO_SHELL_PACKAGE_NAME,
                              'cat', fifo_path]), stdout=pipe)
       atexit.register(_exit_if_needed, stdout_cat)
       stdout_cat.wait()
       if on_fifo_closed:
         on_fifo_closed()
 
-    thread = threading.Thread(target=_run, name="StdoutRedirector")
+    thread = threading.Thread(target=_run, name='StdoutRedirector')
     thread.start()
 
   def _find_available_device_port(self):
     netstat_output = subprocess.check_output(
         self._adb_command(['shell', 'netstat']))
     return _find_available_port(netstat_output)
 
   def _forward_device_port_to_host(self, device_port, host_port):
     """Maps the device port to the host port. If |device_port| is 0, a random
     available port is chosen.
 
     Returns:
       The device port.
     """
     assert host_port
 
     if device_port == 0:
       # TODO(ppi): Should we have a retry loop to handle the unlikely races?
       device_port = self._find_available_device_port()
     subprocess.check_call(self._adb_command([
-        "reverse", "tcp:%d" % device_port, "tcp:%d" % host_port]))
+        'reverse', 'tcp:%d' % device_port, 'tcp:%d' % host_port]))
 
     def _unmap_port():
       unmap_command = self._adb_command([
-          "reverse", "--remove", "tcp:%d" % device_port])
+          'reverse', '--remove', 'tcp:%d' % device_port])
       subprocess.Popen(unmap_command)
     atexit.register(_unmap_port)
     return device_port
 
   def _forward_host_port_to_device(self, host_port, device_port):
     """Maps the host port to the device port. If |host_port| is 0, a random
     available port is chosen.
 
     Returns:
       The host port.
     """
     assert device_port
 
     if host_port == 0:
       # TODO(ppi): Should we have a retry loop to handle the unlikely races?
       host_port = _find_available_host_port()
     subprocess.check_call(self._adb_command([
-        "forward", 'tcp:%d' % host_port, 'tcp:%d' % device_port]))
+        'forward', 'tcp:%d' % host_port, 'tcp:%d' % device_port]))
 
     def _unmap_port():
       unmap_command = self._adb_command([
-          "forward", "--remove", "tcp:%d" % device_port])
+          'forward', '--remove', 'tcp:%d' % device_port])
       subprocess.Popen(unmap_command)
     atexit.register(_unmap_port)
     return host_port
 
   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([
         'shell', 'pm', 'list', 'packages', _MOJO_SHELL_PACKAGE_NAME]))) > 0
 
@@ skipping 92 matching lines @@
     """Starts the mojo shell, passing it the given arguments.
 
     Args:
       arguments: List of arguments for the shell.
       stdout: Valid argument for subprocess.Popen() or None.
     """
     if not self.stop_shell_registered:
       atexit.register(self.stop_shell)
       self.stop_shell_registered = True
 
-    STDOUT_PIPE = "/data/data/%s/stdout.fifo" % _MOJO_SHELL_PACKAGE_NAME
+    STDOUT_PIPE = '/data/data/%s/stdout.fifo' % _MOJO_SHELL_PACKAGE_NAME
 
     cmd = self._adb_command(['shell', 'am', 'start',
                             '-S',
                             '-a', 'android.intent.action.VIEW',
                             '-n', '%s/.MojoShellActivity' %
                             _MOJO_SHELL_PACKAGE_NAME])
 
     parameters = []
     if stdout or on_application_stop:
       # Remove any leftover fifo file after the previous run.
@@ skipping 61 matching lines @@
     def _forward_observatories_as_needed():
       while True:
         line = logcat.stdout.readline()
         if not line:
           break
         match = re.search(r'Observatory listening on http://127.0.0.1:(\d+)',
                           line)
         if match:
           device_port = int(match.group(1))
           host_port = self._forward_host_port_to_device(0, device_port)
-          print ("Dart observatory available at the host at http://127.0.0.1:%d"
+          print ('Dart observatory available at the host at http://127.0.0.1:%d'
                  % host_port)
 
     logcat_watch_thread = threading.Thread(
         target=_forward_observatories_as_needed)
     logcat_watch_thread.daemon = True
     logcat_watch_thread.start()
 
   @overrides(Shell)
   def serve_local_directories(self, mappings, port, reuse_servers=False):
     assert mappings
     if reuse_servers:
       assert port, 'Cannot reuse the server when |port| is 0.'
       server_address = ('127.0.0.1', port)
     else:
       server_address = http_server.start_http_server(mappings, port)
 
     return 'http://127.0.0.1:%d/' % self._forward_device_port_to_host(
         port, server_address[1])
 
   @overrides(Shell)
   def forward_host_port_to_shell(self, host_port):
     self._forward_host_port_to_device(host_port, host_port)
 
   @overrides(Shell)
   def run(self, arguments):
     self.clean_logs()
     self.forward_observatory_ports()
 
-    p = self.show_logs();
+    p = self.show_logs()
     self.start_shell(arguments, sys.stdout, p.terminate)
     p.wait()
     return None
 
   @overrides(Shell)
   def run_and_get_output(self, arguments, timeout=None):
     class Results:
       """Workaround for Python scoping rules that prevent assigning to variables
       from the outer scope.
       """
       output = None
 
     def do_run():
       (r, w) = os.pipe()
-      with os.fdopen(r, "r") as rf:
-        with os.fdopen(w, "w") as wf:
+      with os.fdopen(r, 'r') as rf:
+        with os.fdopen(w, 'w') as wf:
           self.start_shell(arguments, wf, wf.close)
           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