Add docstring inheritance decorator and drop duplicated docstrings.

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 start_http_server
 from devtoolslib.shell import Shell
+from devtoolslib.utils import overrides
 
 
 # Tags used by mojo shell Java logging.
 _LOGCAT_JAVA_TAGS = [
     'AndroidHandler',
     'MojoFileHelper',
     'MojoMain',
     'MojoShellActivity',
     'MojoShellApplication',
 ]
@@ skipping 332 matching lines @@
                           line)
         if match:
           device_port = int(match.group(1))
           host_port = self._ForwardHostPortToDevice(0, device_port)
           print ("Dart observatory available at the host at http://127.0.0.1:%d"
                  % host_port)
 
     logcat_watch_thread = threading.Thread(target=_ForwardObservatoriesAsNeeded)
     logcat_watch_thread.start()
 
+  @overrides(Shell)
   def ServeLocalDirectory(self, local_dir_path, port=0):
-    """Serves the content of the local (host) directory, making it available to
-    the shell under the url returned by the function.
-
-    The server will run on a separate thread until the program terminates. The
-    call returns immediately.
-
-    Args:
-      local_dir_path: path to the directory to be served
-      port: port at which the server will be available to the shell
-
-    Returns:
-      The url that the shell can use to access the content of |local_dir_path|.
-    """
     assert local_dir_path
     mappings = [('', local_dir_path)]
     server_address = start_http_server(mappings, host_port=port)
 
     return 'http://127.0.0.1:%d/' % self._ForwardDevicePortToHost(
         port, server_address[1])
 
+  @overrides(Shell)
   def ServeLocalDirectories(self, mappings, port=0):
-    """Serves the content of the local (host) directories, making it available
-    to the shell under the url returned by the function.
-
-    The server will run on a separate thread until the program terminates. The
-    call returns immediately.
-
-    Args:
-      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. The first matching prefix will be used
-          each time.
-      port: port at which the server will be available to the shell
-
-    Returns:
-      The url that the shell can use to access the content of |local_dir_path|.
-    """
     assert mappings
     server_address = start_http_server(mappings, host_port=port)
 
     return 'http://127.0.0.1:%d/' % self._ForwardDevicePortToHost(
         port, server_address[1])
 
+  @overrides(Shell)
   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.
-    """
     self._ForwardHostPortToDevice(host_port, host_port)
 
+  @overrides(Shell)
   def Run(self, arguments):
-    """Runs the shell with given arguments until shell exits, passing the stdout
-    mingled with stderr produced by the shell onto the stdout.
-
-    Returns:
-      Exit code retured by the shell or None if the exit code cannot be
-      retrieved.
-    """
     self.CleanLogs()
     self.ForwardObservatoryPorts()
 
     # If we are running as root, don't carry over the native logs from logcat -
     # we will have these in the stdout.
     p = self.ShowLogs(include_native_logs=(not self._RunAdbAsRoot()))
     self.StartShell(arguments, sys.stdout, p.terminate)
     p.wait()
     return None
 
+  @overrides(Shell)
   def RunAndGetOutput(self, arguments, timeout=None):
-    """Runs the shell with given arguments until shell exits and returns the
-    output.
-
-    Args:
-      arguments: list of arguments for the shell
-      timeout: maximum running time in seconds, after which the shell will be
-          terminated
-
-    Returns:
-      A tuple of (return_code, output, did_time_out). |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.
-      |did_time_out| is True iff the shell was terminated because it exceeded
-      the |timeout| and False otherwise.
-    """
     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:
           self.StartShell(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.StopShell()
       return None, Results.output, True
     return None, Results.output, False