Unify casing of function names in devtools.

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 json
 import logging
 import os
 import os.path
 import random
 import re
 import subprocess
 import sys
 import tempfile
 import threading
 import time
 
-from devtoolslib.http_server import StartHttpServer
+from devtoolslib.http_server import start_http_server
 from devtoolslib.shell import Shell
 
 
 # Tags used by mojo shell Java logging.
 _LOGCAT_JAVA_TAGS = [
     'AndroidHandler',
     'MojoFileHelper',
     'MojoMain',
     'MojoShellActivity',
     'MojoShellApplication',
 ]
 
 # Tags used by native logging reflected in the logcat.
 _LOGCAT_NATIVE_TAGS = [
     'chromium',
     'sky',
 ]
 
 _MOJO_SHELL_PACKAGE_NAME = 'org.chromium.mojo.shell'
 
 
 _logger = logging.getLogger()
 
 
-def _ExitIfNeeded(process):
+def _exit_if_needed(process):
   """Exits |process| if it is still alive."""
   if process.poll() is None:
     process.kill()
 
 
-def _FindAvailablePort(netstat_output, max_attempts=10000):
+def _find_available_port(netstat_output, max_attempts=10000):
   opened = [int(x.strip().split()[3].split(':')[1])
             for x in netstat_output if x.startswith(' tcp')]
   for _ in xrange(max_attempts):
     port = random.randint(4096, 16384)
     if port not in opened:
       return port
   else:
     raise Exception('Failed to identify an available port.')
 
 
-def _FindAvailableHostPort():
+def _find_available_host_port():
   netstat_output = subprocess.check_output(['netstat'])
-  return _FindAvailablePort(netstat_output)
+  return _find_available_port(netstat_output)
 
 
 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.
   """
@@ skipping 32 matching lines @@
         for _ in xrange(max_attempts):
           if subprocess.check_output(fifo_command)[0] == '0':
             return
           time.sleep(1)
         if on_fifo_closed:
           on_fifo_closed()
         raise Exception("Unable to find fifo.")
       _WaitForFifo()
       stdout_cat = subprocess.Popen(
           self._AdbCommand(['shell', 'cat', fifo_path]), stdout=pipe)
-      atexit.register(_ExitIfNeeded, stdout_cat)
+      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.start()
 
   def _FindAvailableDevicePort(self):
     netstat_output = subprocess.check_output(
         self._AdbCommand(['shell', 'netstat']))
-    return _FindAvailablePort(netstat_output)
+    return _find_available_port(netstat_output)
 
   def _ForwardDevicePortToHost(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
     # Root is not required for `adb forward` (hence we don't check the return
@@ skipping 20 matching lines @@
     available port is chosen.
 
     Returns:
       The host port.
     """
     assert device_port
     self._RunAdbAsRoot()
 
     if host_port == 0:
       # TODO(ppi): Should we have a retry loop to handle the unlikely races?
-      host_port = _FindAvailableHostPort()
+      host_port = _find_available_host_port()
     subprocess.check_call(self._AdbCommand([
         "forward", 'tcp:%d' % host_port, 'tcp:%d' % device_port]))
 
     def _UnmapPort():
       unmap_command = self._AdbCommand([
           "forward", "--remove", "tcp:%d" % device_port])
       subprocess.Popen(unmap_command)
     atexit.register(_UnmapPort)
     return host_port
 
@@ skipping 93 matching lines @@
       self.StopShell()
 
   def StartShell(self,
                  arguments,
                  stdout=None,
                  on_application_stop=None):
     """Starts the mojo shell, passing it the given arguments.
 
     Args:
       arguments: List of arguments for the shell. It must contain the
-          "--origin=" arg.  shell_arguments.ConfigureLocalOrigin() can be used
+          "--origin=" arg. shell_arguments.configure_local_origin() can be used
           to set up a local directory on the host machine as origin.
       stdout: Valid argument for subprocess.Popen() or None.
     """
     if not self.stop_shell_registered:
       atexit.register(self.StopShell)
       self.stop_shell_registered = True
 
     STDOUT_PIPE = "/data/data/%s/stdout.fifo" % _MOJO_SHELL_PACKAGE_NAME
 
     cmd = self._AdbCommand(['shell', 'am', 'start',
@@ skipping 44 matching lines @@
       The process responsible for reading the logs.
     """
     tags = _LOGCAT_JAVA_TAGS
     if include_native_logs:
       tags.extend(_LOGCAT_NATIVE_TAGS)
     if self.additional_logcat_tags is not None:
       tags.extend(self.additional_logcat_tags.split(","))
     logcat = subprocess.Popen(
         self._AdbCommand(['logcat', '-s', ' '.join(tags)]),
         stdout=sys.stdout)
-    atexit.register(_ExitIfNeeded, logcat)
+    atexit.register(_exit_if_needed, logcat)
     return logcat
 
   def ForwardObservatoryPorts(self):
     """Forwards the ports used by the dart observatories to the host machine.
     """
     logcat = subprocess.Popen(self._AdbCommand(['logcat']),
                               stdout=subprocess.PIPE)
-    atexit.register(_ExitIfNeeded, logcat)
+    atexit.register(_exit_if_needed, logcat)
 
     def _ForwardObservatoriesAsNeeded():
       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))
@@ skipping 16 matching lines @@
       local_dir_path: path to the directory to be served
       port: port at which the server will be available to the shell
       additional_mappings: List of tuples (prefix, local_base_path) mapping
           URLs that start with |prefix| to local directory at |local_base_path|.
           The prefixes should skip the leading slash.
 
     Returns:
       The url that the shell can use to access the content of |local_dir_path|.
     """
     assert local_dir_path
-    server_address = StartHttpServer(local_dir_path, host_port=port,
-                                     additional_mappings=additional_mappings)
+    server_address = start_http_server(local_dir_path, host_port=port,
+                                       additional_mappings=additional_mappings)
 
     return 'http://127.0.0.1:%d/' % self._ForwardDevicePortToHost(
         port, server_address[1])
 
   def ForwardHostPortToShell(self, host_port):
     """Forwards a port on the host machine to the same port wherever the shell
     is running.
 
     This is a no-op if the shell is running locally.
     """
@@ skipping 27 matching lines @@
       A tuple of (return_code, output). |return_code| is the exit code returned
       by the shell or None if the exit code cannot be retrieved. |output| is the
       stdout mingled with the stderr produced by the shell.
     """
     (r, w) = os.pipe()
     with os.fdopen(r, "r") as rf:
       with os.fdopen(w, "w") as wf:
         self.StartShell(arguments, wf, wf.close)
         output = rf.read()
         return None, output