Quick spelling clean-up in the auto-bisect code.

tools/bisect-perf-regression.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 """Performance Test Bisect Tool
 
 This script bisects a series of changelists using binary search. It starts at
 a bad revision where a performance metric has regressed, and asks for a last
 known-good revision. It will then binary search across this revision range by
 syncing, building, and running a performance test. If the change is
 suspected to occur as a result of WebKit/V8 changes, the script will
 further bisect changes to those depots and attempt to narrow down the revision
 range.
 
-
-An example usage (using svn cl's):
+Example usage using SVN revisions:
 
 ./tools/bisect-perf-regression.py -c\
   "out/Release/performance_ui_tests --gtest_filter=ShutdownTest.SimpleUserQuit"\
   -g 168222 -b 168232 -m shutdown/simple-user-quit
 
-Be aware that if you're using the git workflow and specify an svn revision,
-the script will attempt to find the git SHA1 where svn changes up to that
+Be aware that if you're using the git workflow and specify an SVN revision,
+the script will attempt to find the git SHA1 where SVN changes up to that
 revision were merged in.
 
-
-An example usage (using git hashes):
+Example usage using git hashes:
 
 ./tools/bisect-perf-regression.py -c\
   "out/Release/performance_ui_tests --gtest_filter=ShutdownTest.SimpleUserQuit"\
   -g 1f6e67861535121c5c819c16a666f2436c207e7b\
   -b b732f23b4f81c382db0b23b9035f3dadc7d925bb\
   -m shutdown/simple-user-quit
 """
 
 import copy
 import datetime
@@ skipping 113 matching lines @@
 
 DEPOT_NAMES = DEPOT_DEPS_NAME.keys()
 
 CROS_CHROMEOS_PATTERN = 'chromeos-base/chromeos-chrome'
 
 # Possible return values from BisectPerformanceMetrics.SyncBuildAndRunRevision.
 BUILD_RESULT_SUCCEED = 0
 BUILD_RESULT_FAIL = 1
 BUILD_RESULT_SKIPPED = 2
 
-# Maximum time in seconds to wait after posting build request to tryserver.
+# Maximum time in seconds to wait after posting build request to the try server.
 # TODO: Change these values based on the actual time taken by buildbots on
-# the tryserver.
+# the try server.
 MAX_MAC_BUILD_TIME = 14400
 MAX_WIN_BUILD_TIME = 14400
 MAX_LINUX_BUILD_TIME = 14400
 
 # The confidence percentage at which confidence can be consider "high".
 HIGH_CONFIDENCE = 95
 
 # Patch template to add a new file, DEPS.sha under src folder.
 # This file contains SHA1 value of the DEPS changes made while bisecting
-# dependency repositories. This patch send along with DEPS patch to tryserver.
-# When a build requested is posted with a patch, bisect builders on tryserver,
+# dependency repositories. This patch send along with DEPS patch to try server.
+# When a build requested is posted with a patch, bisect builders on try server,
 # once build is produced, it reads SHA value from this file and appends it
 # to build archive filename.
 DEPS_SHA_PATCH = """diff --git src/DEPS.sha src/DEPS.sha
 new file mode 100644
 --- /dev/null
 +++ src/DEPS.sha
 @@ -0,0 +1 @@
 +%(deps_sha)s
 """
 
@@ skipping 24 matching lines @@
 Author  : %(author)s%(email_info)s%(commit_info)s
 Commit  : %(cl)s
 Date    : %(cl_date)s"""
 
 REPRO_STEPS_LOCAL = """
 ==== INSTRUCTIONS TO REPRODUCE ====
 To run locally:
 $%(command)s"""
 
 REPRO_STEPS_TRYJOB = """
-To reproduce on Performance trybot:
+To reproduce on a performance try bot:
 1. Create new git branch or check out existing branch.
 2. Edit tools/run-perf-test.cfg (instructions in file) or \
 third_party/WebKit/Tools/run-perf-test.cfg.
   a) Take care to strip any src/ directories from the head of \
 relative path names.
   b) On desktop, only --browser=release is supported, on android \
 --browser=android-chromium-testshell.
   c) Test command to use: %(command)s
 3. Upload your patch. --bypass-hooks is necessary to upload the changes you \
 committed locally to run-perf-test.cfg.
    Note: *DO NOT* commit run-perf-test.cfg changes to the project repository.
    $ git cl upload --bypass-hooks
-4. Send your try job to the tryserver. \
+4. Send your try job to the try server. \
 [Please make sure to use appropriate bot to reproduce]
    $ git cl try -m tryserver.chromium.perf -b <bot>
 
 For more details please visit
 https://sites.google.com/a/chromium.org/dev/developers/performance-try-bots"""
 
 RESULTS_THANKYOU = """
 ===== THANK YOU FOR CHOOSING BISECT AIRLINES =====
 Visit http://www.chromium.org/developers/core-principles for Chrome's policy
 on perf regressions.
@@ skipping 58 matching lines @@
 def GetSHA1HexDigest(contents):
   """Returns SHA1 hex digest of the given string."""
   return hashlib.sha1(contents).hexdigest()
 
 
 def GetZipFileName(build_revision=None, target_arch='ia32', patch_sha=None):
   """Gets the archive file name for the given revision."""
   def PlatformName():
     """Return a string to be used in paths for the platform."""
     if bisect_utils.IsWindowsHost():
-      # Build archive for x64 is still stored with 'win32'suffix
-      # (chromium_utils.PlatformName()).
+      # Build archive for x64 is still stored with the "win32" suffix.
+      # See chromium_utils.PlatformName().
       if bisect_utils.Is64BitWindows() and target_arch == 'x64':
         return 'win32'
       return 'win32'
     if bisect_utils.IsLinuxHost():
-      # Android builds too are archived with full-build-linux* prefix.
+      # Android builds are also archived with the "full-build-linux prefix.
       return 'linux'
     if bisect_utils.IsMacHost():
       return 'mac'
     raise NotImplementedError('Unknown platform "%s".' % sys.platform)
 
   base_name = 'full-build-%s' % PlatformName()
   if not build_revision:
     return base_name
   if patch_sha:
     build_revision = '%s_%s' % (build_revision , patch_sha)
   return '%s_%s.zip' % (base_name, build_revision)
 
 
 def GetRemoteBuildPath(build_revision, target_platform='chromium',
                        target_arch='ia32', patch_sha=None):
-  """Compute the url to download the build from."""
+  """Returns the URL to download the build from."""
   def GetGSRootFolderName(target_platform):
-    """Gets Google Cloud Storage root folder names"""
+    """Returns the Google Cloud Storage root folder name."""
     if bisect_utils.IsWindowsHost():
       if bisect_utils.Is64BitWindows() and target_arch == 'x64':
         return 'Win x64 Builder'
       return 'Win Builder'
     if bisect_utils.IsLinuxHost():
       if target_platform == 'android':
         return 'android_perf_rel'
       return 'Linux Builder'
     if bisect_utils.IsMacHost():
       return 'Mac Builder'
     raise NotImplementedError('Unsupported Platform "%s".' % sys.platform)
 
   base_filename = GetZipFileName(
       build_revision, target_arch, patch_sha)
   builder_folder = GetGSRootFolderName(target_platform)
   return '%s/%s' % (builder_folder, base_filename)
 
 
 def FetchFromCloudStorage(bucket_name, source_path, destination_path):
   """Fetches file(s) from the Google Cloud Storage.
 
   Args:
     bucket_name: Google Storage bucket name.
     source_path: Source file path.
     destination_path: Destination file path.
 
   Returns:
-    Downloaded file path if exisits, otherwise None.
+    Downloaded file path if exists, otherwise None.
   """
   target_file = os.path.join(destination_path, os.path.basename(source_path))
   try:
     if cloud_storage.Exists(bucket_name, source_path):
       print 'Fetching file from gs//%s/%s ...' % (bucket_name, source_path)
       cloud_storage.Get(bucket_name, source_path, destination_path)
       if os.path.exists(target_file):
         return target_file
     else:
       print ('File gs://%s/%s not found in cloud storage.' % (
           bucket_name, source_path))
   except Exception as e:
     print 'Something went wrong while fetching file from cloud: %s' % e
     if os.path.exists(target_file):
       os.remove(target_file)
   return None
 
 
-# This is copied from Chromium's project build/scripts/common/chromium_utils.py.
+# This is copied from build/scripts/common/chromium_utils.py.
 def MaybeMakeDirectory(*path):
   """Creates an entire path, if it doesn't already exist."""
   file_path = os.path.join(*path)
   try:
     os.makedirs(file_path)
   except OSError as e:
     if e.errno != errno.EEXIST:
       return False
   return True
 
 
-# This is copied from Chromium's project build/scripts/common/chromium_utils.py.
+# This was copied from build/scripts/common/chromium_utils.py.
 def ExtractZip(filename, output_dir, verbose=True):
   """ Extract the zip archive in the output directory."""
   MaybeMakeDirectory(output_dir)
 
   # On Linux and Mac, we use the unzip command as it will
   # handle links and file bits (executable), which is much
   # easier then trying to do that with ZipInfo options.
   #
   # The Mac Version of unzip unfortunately does not support Zip64, whereas
-  # the python module does, so we have to fallback to the python zip module
-  # on Mac if the filesize is greater than 4GB.
+  # the python module does, so we have to fall back to the python zip module
+  # on Mac if the file size is greater than 4GB.
   #
   # On Windows, try to use 7z if it is installed, otherwise fall back to python
   # zip module and pray we don't have files larger than 512MB to unzip.
   unzip_cmd = None
   if ((bisect_utils.IsMacHost()
        and os.path.getsize(filename) < 4 * 1024 * 1024 * 1024)
       or bisect_utils.IsLinuxHost()):
     unzip_cmd = ['unzip', '-o']
   elif (bisect_utils.IsWindowsHost()
         and os.path.exists('C:\\Program Files\\7-Zip\\7z.exe')):
@@ skipping 16 matching lines @@
       if verbose:
         print 'Extracting %s' % name
       zf.extract(name, output_dir)
       if bisect_utils.IsMacHost():
         # Restore permission bits.
         os.chmod(os.path.join(output_dir, name),
                  zf.getinfo(name).external_attr >> 16L)
 
 
 def WriteStringToFile(text, file_name):
+  """Writes text to a file, raising an RuntimeError on failure."""
   try:
     with open(file_name, 'wb') as f:
       f.write(text)
   except IOError:
     raise RuntimeError('Error writing to file [%s]' % file_name )
 
 
 def ReadStringFromFile(file_name):
+  """Writes text to a file, raising an RuntimeError on failure."""
   try:
     with open(file_name) as f:
       return f.read()
   except IOError:
     raise RuntimeError('Error reading file [%s]' % file_name )
 
 
 def ChangeBackslashToSlashInPatch(diff_text):
-  """Formats file paths in the given text to unix-style paths."""
-  if diff_text:
-    diff_lines = diff_text.split('\n')
-    for i in range(len(diff_lines)):
-      if (diff_lines[i].startswith('--- ') or
-          diff_lines[i].startswith('+++ ')):
-        diff_lines[i] = diff_lines[i].replace('\\', '/')
-    return '\n'.join(diff_lines)
-  return None
+  """Formats file paths in the given patch text to Unix-style paths."""
+  if not diff_text:
+    return None
+  diff_lines = diff_text.split('\n')
+  for i in range(len(diff_lines)):
+    line = diff_lines[i]
+    if line.startswith('--- ') or line.startswith('+++ '):
+      diff_lines[i] = line.replace('\\', '/')
+  return '\n'.join(diff_lines)
 
 
 def _ParseRevisionsFromDEPSFileManually(deps_file_contents):
-  """Parses the vars section of the DEPS file with regex.
+  """Parses the vars section of the DEPS file using regular expressions.
 
   Args:
     deps_file_contents: The DEPS file contents as a string.
 
   Returns:
-    A dict in the format {depot:revision} if successful, otherwise None.
+    A dictionary in the format {depot: revision} if successful, otherwise None.
   """
   # We'll parse the "vars" section of the DEPS file.
   rxp = re.compile('vars = {(?P<vars_body>[^}]+)', re.MULTILINE)
   re_results = rxp.search(deps_file_contents)
 
   if not re_results:
     return None
 
   # We should be left with a series of entries in the vars component of
   # the DEPS file with the following format:
   # 'depot_name': 'revision',
   vars_body = re_results.group('vars_body')
   rxp = re.compile("'(?P<depot_body>[\w_-]+)':[\s]+'(?P<rev_body>[\w@]+)'",
                    re.MULTILINE)
   re_results = rxp.findall(vars_body)
 
   return dict(re_results)
 
 
 def _WaitUntilBuildIsReady(
     fetch_build, bot_name, builder_host, builder_port, build_request_id,
     max_timeout):
-  """Waits until build is produced by bisect builder on tryserver.
+  """Waits until build is produced by bisect builder on try server.
 
   Args:
     fetch_build: Function to check and download build from cloud storage.
-    bot_name: Builder bot name on tryserver.
-    builder_host Tryserver hostname.
-    builder_port: Tryserver port.
-    build_request_id: A unique ID of the build request posted to tryserver.
+    bot_name: Builder bot name on try server.
+    builder_host Try server host name.
+    builder_port: Try server port.
+    build_request_id: A unique ID of the build request posted to try server.
     max_timeout: Maximum time to wait for the build.
 
   Returns:
      Downloaded archive file path if exists, otherwise None.
   """
-  # Build number on the tryserver.
+  # Build number on the try server.
   build_num = None
   # Interval to check build on cloud storage.
   poll_interval = 60
-  # Interval to check build status on tryserver.
+  # Interval to check build status on try server in seconds.
   status_check_interval = 600
   last_status_check = time.time()
   start_time = time.time()
   while True:
     # Checks for build on gs://chrome-perf and download if exists.
     res = fetch_build()
     if res:
       return (res, 'Build successfully found')
     elapsed_status_check = time.time() - last_status_check
-    # To avoid overloading tryserver with status check requests, we check
-    # build status for every 10 mins.
+    # To avoid overloading try server with status check requests, we check
+    # build status for every 10 minutes.
     if elapsed_status_check > status_check_interval:
       last_status_check = time.time()
       if not build_num:
-        # Get the build number on tryserver for the current build.
+        # Get the build number on try server for the current build.
         build_num = bisect_builder.GetBuildNumFromBuilder(
             build_request_id, bot_name, builder_host, builder_port)
       # Check the status of build using the build number.
       # Note: Build is treated as PENDING if build number is not found
-      # on the the tryserver.
+      # on the the try server.
       build_status, status_link = bisect_builder.GetBuildStatus(
           build_num, bot_name, builder_host, builder_port)
       if build_status == bisect_builder.FAILED:
         return (None, 'Failed to produce build, log: %s' % status_link)
     elapsed_time = time.time() - start_time
     if elapsed_time > max_timeout:
       return (None, 'Timed out: %ss without build' % max_timeout)
 
     print 'Time elapsed: %ss without build.' % elapsed_time
     time.sleep(poll_interval)
@@ skipping 228 matching lines @@
     if arg_dict.has_key('--profile-dir') and arg_dict.has_key('--browser'):
       profile_path, profile_type = os.path.split(arg_dict['--profile-dir'])
       return not bisect_utils.RunProcess(['python', path_to_generate,
           '--profile-type-to-generate', profile_type,
           '--browser', arg_dict['--browser'], '--output-dir', profile_path])
     return False
   return True
 
 
 def _AddRevisionsIntoRevisionData(revisions, depot, sort, revision_data):
-  """Adds new revisions to the revision_data dict and initializes them.
+  """Adds new revisions to the revision_data dictionary and initializes them.
 
   Args:
     revisions: List of revisions to add.
     depot: Depot that's currently in use (src, webkit, etc...)
     sort: Sorting key for displaying revisions.
-    revision_data: A dict to add the new revisions into. Existing revisions
-      will have their sort keys offset.
+    revision_data: A dictionary to add the new revisions into.
+        Existing revisions will have their sort keys adjusted.
   """
   num_depot_revisions = len(revisions)
 
   for _, v in revision_data.iteritems():
     if v['sort'] > sort:
       v['sort'] += num_depot_revisions
 
   for i in xrange(num_depot_revisions):
     r = revisions[i]
     revision_data[r] = {
@@ skipping 46 matching lines @@
   print 'Average build time : %s' % datetime.timedelta(
       seconds=int(step_build_time_avg))
   print 'Average test time  : %s' % datetime.timedelta(
       seconds=int(step_perf_time_avg))
 
 
 def _FindOtherRegressions(revision_data_sorted, bad_greater_than_good):
   """Compiles a list of other possible regressions from the revision data.
 
   Args:
-    revision_data_sorted: Sorted list of (revision, revision data dict) pairs.
+    revision_data_sorted: Sorted list of (revision, revision data) pairs.
     bad_greater_than_good: Whether the result value at the "bad" revision is
         numerically greater than the result value at the "good" revision.
 
   Returns:
     A list of [current_rev, previous_rev, confidence] for other places where
     there may have been a regression.
   """
   other_regressions = []
   previous_values = []
   previous_id = None
@@ skipping 209 matching lines @@
         if (depot_data.get('recurse') and depot in depot_data.get('from')):
           depot_data_src = depot_data.get('src') or depot_data.get('src_old')
           src_dir = deps_data.get(depot_data_src)
           if src_dir:
             self.depot_cwd[depot_name] = os.path.join(self.src_cwd,
                                                       depot_data_src[4:])
             re_results = rxp.search(src_dir)
             if re_results:
               results[depot_name] = re_results.group('revision')
             else:
-              warning_text = ('Couldn\'t parse revision for %s while bisecting '
+              warning_text = ('Could not parse revision for %s while bisecting '
                               '%s' % (depot_name, depot))
               if not warning_text in self.warnings:
                 self.warnings.append(warning_text)
           else:
             results[depot_name] = None
       return results
     except ImportError:
       deps_file_contents = ReadStringFromFile(bisect_utils.FILE_DEPS_GIT)
       parse_results = _ParseRevisionsFromDEPSFileManually(deps_file_contents)
       results = {}
       for depot_name, depot_revision in parse_results.iteritems():
         depot_revision = depot_revision.strip('@')
         print depot_name, depot_revision
         for current_name, current_data in DEPOT_DEPS_NAME.iteritems():
           if (current_data.has_key('deps_var') and
               current_data['deps_var'] == depot_name):
             src_name = current_name
             results[src_name] = depot_revision
             break
       return results
 
   def _Get3rdPartyRevisions(self, depot):
     """Parses the DEPS file to determine WebKit/v8/etc... versions.
 
+    Args:
+      depot: A depot name. Should be in the DEPOT_NAMES list.
+
     Returns:
-      A dict in the format {depot:revision} if successful, otherwise None.
+      A dict in the format {depot: revision} if successful, otherwise None.
     """
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory(depot)
 
     results = {}
 
     if depot == 'chromium' or depot == 'android-chrome':
       results = self._ParseRevisionsFromDEPSFile(depot)
       os.chdir(cwd)
 
@@ skipping 167 matching lines @@
       # Cleanup any leftovers from unzipping.
       if os.path.exists(output_dir):
         RmTreeAndMkDir(output_dir, skip_makedir=True)
     finally:
       # Delete downloaded archive
       if os.path.exists(downloaded_file):
         os.remove(downloaded_file)
     return False
 
   def PostBuildRequestAndWait(self, revision, fetch_build, patch=None):
-    """POSTs the build request job to the tryserver instance.
+    """POSTs the build request job to the try server instance.
 
     A try job build request is posted to tryserver.chromium.perf master,
     and waits for the binaries to be produced and archived on cloud storage.
     Once the build is ready and stored onto cloud, build archive is downloaded
     into the output folder.
 
     Args:
       revision: A Git hash revision.
       fetch_build: Function to check and download build from cloud storage.
       patch: A DEPS patch (used while bisecting 3rd party repositories).
@@ skipping 23 matching lines @@
       if bisect_utils.IsMacHost():
         return ('mac_perf_bisect_builder', MAX_MAC_BUILD_TIME)
       raise NotImplementedError('Unsupported Platform "%s".' % sys.platform)
     if not fetch_build:
       return False
 
     bot_name, build_timeout = GetBuilderNameAndBuildTime(
        self.opts.target_platform, self.opts.target_arch)
     builder_host = self.opts.builder_host
     builder_port = self.opts.builder_port
-    # Create a unique ID for each build request posted to tryserver builders.
-    # This ID is added to "Reason" property in build's json.
+    # Create a unique ID for each build request posted to try server builders.
+    # This ID is added to "Reason" property of the build.
     build_request_id = GetSHA1HexDigest(
         '%s-%s-%s' % (svn_revision, patch, time.time()))
 
     # Creates a try job description.
     job_args = {
         'revision': 'src@%s' % svn_revision,
         'bot': bot_name,
         'name': build_request_id,
     }
     # Update patch information if supplied.
     if patch:
       job_args['patch'] = patch
     # Posts job to build the revision on the server.
     if bisect_builder.PostTryJob(builder_host, builder_port, job_args):
       target_file, error_msg = _WaitUntilBuildIsReady(
           fetch_build, bot_name, builder_host, builder_port, build_request_id,
           build_timeout)
       if not target_file:
         print '%s [revision: %s]' % (error_msg, svn_revision)
         return None
       return target_file
     print 'Failed to post build request for revision: [%s]' % svn_revision
     return None
 
   def IsDownloadable(self, depot):
-    """Checks if build is downloadable based on target platform and depot."""
+    """Checks if build can be downloaded based on target platform and depot."""
     if (self.opts.target_platform in ['chromium', 'android'] and
         self.opts.gs_bucket):
       return (depot == 'chromium' or
               'chromium' in DEPOT_DEPS_NAME[depot]['from'] or
               'v8' in DEPOT_DEPS_NAME[depot]['from'])
     return False
 
   def UpdateDeps(self, revision, depot, deps_file):
     """Updates DEPS file with new revision of dependency repository.
 
@@ skipping 144 matching lines @@
   def _IsBisectModeReturnCode(self):
     return self.opts.bisect_mode in [BISECT_MODE_RETURN_CODE]
 
   def _IsBisectModeStandardDeviation(self):
     return self.opts.bisect_mode in [BISECT_MODE_STD_DEV]
 
   def GetCompatibleCommand(self, command_to_run, revision, depot):
     # Prior to crrev.com/274857 *only* android-chromium-testshell
     # Then until crrev.com/276628 *both* (android-chromium-testshell and
     # android-chrome-shell) work. After that rev 276628 *only*
-    # android-chrome-shell works. bisect-perf-reggresion.py script should
+    # android-chrome-shell works. bisect-perf-regression.py script should
     # handle these cases and set appropriate browser type based on revision.
     if self.opts.target_platform in ['android']:
       # When its a third_party depot, get the chromium revision.
       if depot != 'chromium':
         revision = bisect_utils.CheckRunGit(
             ['rev-parse', 'HEAD'], cwd=self.src_cwd).strip()
       svn_revision = self.source_control.SVNFindRev(revision, cwd=self.src_cwd)
       if not svn_revision:
         return command_to_run
       cmd_re = re.compile('--browser=(?P<browser_type>\S+)')
@@ skipping 145 matching lines @@
           'std_dev': standard_dev,
           'values': metric_values,
       }
 
       print 'Results of performance test: %12f %12f' % (
           truncated_mean, standard_err)
       print
     return (values, success_code, output_of_all_runs)
 
   def FindAllRevisionsToSync(self, revision, depot):
-    """Finds all dependant revisions and depots that need to be synced for a
-    given revision. This is only useful in the git workflow, as an svn depot
-    may be split into multiple mirrors.
+    """Finds all dependent revisions and depots that need to be synced.
 
-    ie. skia is broken up into 3 git mirrors over skia/src, skia/gyp, and
-    skia/include. To sync skia/src properly, one has to find the proper
-    revisions in skia/gyp and skia/include.
+    For example skia is broken up into 3 git mirrors over skia/src,
+    skia/gyp, and skia/include. To sync skia/src properly, one has to find
+    the proper revisions in skia/gyp and skia/include.
+
+    This is only useful in the git workflow, as an SVN depot may be split into
+    multiple mirrors.
 
     Args:
       revision: The revision to sync to.
       depot: The depot in use at the moment (probably skia).
 
     Returns:
       A list of [depot, revision] pairs that need to be synced.
     """
     revisions_to_sync = [[depot, revision]]
 
     is_base = ((depot == 'chromium') or (depot == 'cros') or
         (depot == 'android-chrome'))
 
     # Some SVN depots were split into multiple git depots, so we need to
     # figure out for each mirror which git revision to grab. There's no
-    # guarantee that the SVN revision will exist for each of the dependant
+    # guarantee that the SVN revision will exist for each of the dependent
     # depots, so we have to grep the git logs and grab the next earlier one.
     if (not is_base
         and DEPOT_DEPS_NAME[depot]['depends']
         and self.source_control.IsGit()):
       svn_rev = self.source_control.SVNFindRev(revision)
 
       for d in DEPOT_DEPS_NAME[depot]['depends']:
         self.ChangeToDepotWorkingDirectory(d)
 
         dependant_rev = self.source_control.ResolveToRevision(
             svn_rev, d, DEPOT_DEPS_NAME, -1000)
 
         if dependant_rev:
           revisions_to_sync.append([d, dependant_rev])
 
       num_resolved = len(revisions_to_sync)
       num_needed = len(DEPOT_DEPS_NAME[depot]['depends'])
 
       self.ChangeToDepotWorkingDirectory(depot)
 
       if not ((num_resolved - 1) == num_needed):
         return None
 
     return revisions_to_sync
 
   def PerformPreBuildCleanup(self):
-    """Performs necessary cleanup between runs."""
+    """Performs cleanup between runs."""
     print 'Cleaning up between runs.'
     print
 
-    # Having these pyc files around between runs can confuse the
-    # perf tests and cause them to crash.
+    # Leaving these .pyc files around between runs may disrupt some perf tests.
     for (path, _, files) in os.walk(self.src_cwd):
       for cur_file in files:
         if cur_file.endswith('.pyc'):
           path_to_file = os.path.join(path, cur_file)
           os.remove(path_to_file)
 
   def PerformWebkitDirectoryCleanup(self, revision):
-    """If the script is switching between Blink and WebKit during bisect,
+    """Cleans up the Webkit directory before syncing another revision.
+
+    If the script is switching between Blink and WebKit during bisect,
     its faster to just delete the directory rather than leave it up to git
     to sync.
 
     Returns:
       True if successful.
     """
     if not self.source_control.CheckoutFileAtRevision(
         bisect_utils.FILE_DEPS_GIT, revision, cwd=self.src_cwd):
       return False
 
@@ skipping 11 matching lines @@
     if self.was_blink != is_blink:
       self.was_blink = is_blink
       # Removes third_party/Webkit directory.
       return bisect_utils.RemoveThirdPartyDirectory('Webkit')
     return True
 
   def PerformCrosChrootCleanup(self):
     """Deletes the chroot.
 
     Returns:
-        True if successful.
+      True if successful.
     """
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory('cros')
     cmd = [bisect_utils.CROS_SDK_PATH, '--delete']
     return_code = bisect_utils.RunProcess(cmd)
     os.chdir(cwd)
     return not return_code
 
   def CreateCrosChroot(self):
     """Creates a new chroot.
 
     Returns:
-        True if successful.
+      True if successful.
     """
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory('cros')
     cmd = [bisect_utils.CROS_SDK_PATH, '--create']
     return_code = bisect_utils.RunProcess(cmd)
     os.chdir(cwd)
     return not return_code
 
   def PerformPreSyncCleanup(self, revision, depot):
     """Performs any necessary cleanup before syncing.
 
     Returns:
       True if successful.
     """
     if depot == 'chromium' or depot == 'android-chrome':
       # Removes third_party/libjingle. At some point, libjingle was causing
       # issues syncing when using the git workflow (crbug.com/266324).
       os.chdir(self.src_cwd)
       if not bisect_utils.RemoveThirdPartyDirectory('libjingle'):
         return False
       # Removes third_party/skia. At some point, skia was causing
-      #  issues syncing when using the git workflow (crbug.com/377951).
+      # issues syncing when using the git workflow (crbug.com/377951).
       if not bisect_utils.RemoveThirdPartyDirectory('skia'):
         return False
       if depot == 'chromium':
         # The fast webkit cleanup doesn't work for android_chrome
         # The switch from Webkit to Blink that this deals with now happened
         # quite a long time ago so this is unlikely to be a problem.
         return self.PerformWebkitDirectoryCleanup(revision)
     elif depot == 'cros':
       return self.PerformCrosChrootCleanup()
     return True
 
   def RunPostSync(self, depot):
     """Performs any work after syncing.
 
     Returns:
       True if successful.
     """
     if self.opts.target_platform == 'android':
       if not builder.SetupAndroidBuildEnvironment(self.opts,
           path_to_src=self.src_cwd):
         return False
 
     if depot == 'cros':
       return self.CreateCrosChroot()
     else:
       return self.RunGClientHooks()
     return True
 
   def ShouldSkipRevision(self, depot, revision):
-    """Some commits can be safely skipped (such as a DEPS roll), since the tool
+    """Checks whether a particular revision can be safely skipped.
+
+    Some commits can be safely skipped (such as a DEPS roll), since the tool
     is git based those changes would have no effect.
 
     Args:
       depot: The depot being bisected.
       revision: Current revision we're synced to.
 
     Returns:
       True if we should skip building/testing this revision.
     """
     if depot == 'chromium':
@@ skipping 24 matching lines @@
     """
     sync_client = None
     if depot == 'chromium' or depot == 'android-chrome':
       sync_client = 'gclient'
     elif depot == 'cros':
       sync_client = 'repo'
 
     revisions_to_sync = self.FindAllRevisionsToSync(revision, depot)
 
     if not revisions_to_sync:
-      return ('Failed to resolve dependant depots.', BUILD_RESULT_FAIL)
+      return ('Failed to resolve dependent depots.', BUILD_RESULT_FAIL)
 
     if not self.PerformPreSyncCleanup(revision, depot):
       return ('Failed to perform pre-sync cleanup.', BUILD_RESULT_FAIL)
 
     success = True
 
     if not self.opts.debug_ignore_sync:
       for r in revisions_to_sync:
         self.ChangeToDepotWorkingDirectory(r[0])
 
         if sync_client:
           self.PerformPreBuildCleanup()
 
         # If you're using gclient to sync, you need to specify the depot you
         # want so that all the dependencies sync properly as well.
-        # ie. gclient sync src@<SHA1>
+        # i.e. gclient sync src@<SHA1>
         current_revision = r[1]
         if sync_client == 'gclient':
           current_revision = '%s@%s' % (DEPOT_DEPS_NAME[depot]['src'],
               current_revision)
         if not self.source_control.SyncToRevision(current_revision,
             sync_client):
           success = False
 
           break
 
     if success:
       success = self.RunPostSync(depot)
       if success:
         if skippable and self.ShouldSkipRevision(depot, revision):
           return ('Skipped revision: [%s]' % str(revision),
                   BUILD_RESULT_SKIPPED)
 
         start_build_time = time.time()
         if self.BuildCurrentRevision(depot, revision):
           after_build_time = time.time()
           # Hack to support things that got changed.
           command_to_run = self.GetCompatibleCommand(
               command_to_run, revision, depot)
           results = self.RunPerformanceTestAndParseResults(command_to_run,
                                                            metric)
           # Restore build output directory once the tests are done, to avoid
-          # any descrepancy.
+          # any discrepancies.
           if self.IsDownloadable(depot) and revision:
             self.BackupOrRestoreOutputdirectory(restore=True)
 
           if results[1] == 0:
             external_revisions = self._Get3rdPartyRevisions(depot)
 
             if not external_revisions is None:
               return (results[0], results[1], external_revisions,
                   time.time() - after_build_time, after_build_time -
                   start_build_time)
@@ skipping 266 matching lines @@
 
       output = bisect_utils.CheckRunGit(cmd, cwd=cwd)
       good_commit_time = int(output)
 
       cmd = ['log', '--format=%ct', '-1', bad_revision]
       output = bisect_utils.CheckRunGit(cmd, cwd=cwd)
       bad_commit_time = int(output)
 
       return good_commit_time <= bad_commit_time
     else:
-      # Cros/svn use integers
+      # CrOS and SVN use integers.
       return int(good_revision) <= int(bad_revision)
 
   def CanPerformBisect(self, revision_to_check):
     """Checks whether a given revision is bisectable.
 
     Note: At present it checks whether a given revision is bisectable on
     android bots(refer crbug.com/385324).
 
     Args:
       revision_to_check: Known good revision.
 
     Returns:
       A dictionary indicating the result. If revision is not bisectable,
       this will contain the field "error", otherwise None.
     """
     if self.opts.target_platform == 'android':
       revision_to_check = self.source_control.SVNFindRev(revision_to_check)
       if (bisect_utils.IsStringInt(revision_to_check)
           and revision_to_check < 265549):
         return {'error': (
-            'Bisect cannot conitnue for the given revision range.\n'
+            'Bisect cannot continue for the given revision range.\n'
             'It is impossible to bisect Android regressions '
             'prior to r265549, which allows the bisect bot to '
             'rely on Telemetry to do apk installation of the most recently '
             'built local ChromeShell(refer to crbug.com/385324).\n'
             'Please try bisecting revisions greater than or equal to r265549.')}
     return None
 
   def Run(self, command_to_run, bad_revision_in, good_revision_in, metric):
     """Given known good and bad revisions, run a binary search on all
     intermediate revisions to determine the CL where the performance regression
     occurred.
 
     Args:
       command_to_run: Specify the command to execute the performance test.
       good_revision: Number/tag of the known good revision.
       bad_revision: Number/tag of the known bad revision.
       metric: The performance metric to monitor.
 
     Returns:
       A dict with 2 members, 'revision_data' and 'error'. On success,
       'revision_data' will contain a dict mapping revision ids to
       data about that revision. Each piece of revision data consists of a
       dict with the following keys:
 
       'passed': Represents whether the performance test was successful at
           that revision. Possible values include: 1 (passed), 0 (failed),
           '?' (skipped), 'F' (build failed).
-      'depot': The depot that this revision is from (ie. WebKit)
+      'depot': The depot that this revision is from (i.e. WebKit)
       'external': If the revision is a 'src' revision, 'external' contains
           the revisions of each of the external libraries.
       'sort': A sort value for sorting the dict in order of commits.
 
       For example:
       {
         'error':None,
         'revision_data':
         {
           'CL #1':
           {
-            'passed':False,
-            'depot':'chromium',
-            'external':None,
-            'sort':0
+            'passed': False,
+            'depot': 'chromium',
+            'external': None,
+            'sort': 0
           }
         }
       }
 
       If an error occurred, the 'error' field will contain the message and
       'revision_data' will be empty.
     """
     results = {
         'revision_data' : {},
         'error' : None,
     }
 
     # Choose depot to bisect first
     target_depot = 'chromium'
     if self.opts.target_platform == 'cros':
       target_depot = 'cros'
     elif self.opts.target_platform == 'android-chrome':
       target_depot = 'android-chrome'
 
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory(target_depot)
 
-    # If they passed SVN CL's, etc... we can try match them to git SHA1's.
+    # If they passed SVN revisions, we can try match them to git SHA1 hashes.
     bad_revision = self.source_control.ResolveToRevision(
         bad_revision_in, target_depot, DEPOT_DEPS_NAME, 100)
     good_revision = self.source_control.ResolveToRevision(
         good_revision_in, target_depot, DEPOT_DEPS_NAME, -100)
 
     os.chdir(cwd)
 
     if bad_revision is None:
-      results['error'] = 'Could\'t resolve [%s] to SHA1.' % (bad_revision_in,)
+      results['error'] = 'Couldn\'t resolve [%s] to SHA1.' % bad_revision_in
       return results
 
     if good_revision is None:
-      results['error'] = 'Could\'t resolve [%s] to SHA1.' % (good_revision_in,)
+      results['error'] = 'Couldn\'t resolve [%s] to SHA1.' % good_revision_in
       return results
 
     # Check that they didn't accidentally swap good and bad revisions.
     if not self.CheckIfRevisionsInProperOrder(
         target_depot, good_revision, bad_revision):
       results['error'] = ('bad_revision < good_revision, did you swap these '
                           'by mistake?')
       return results
 
     bad_revision, good_revision = self.NudgeRevisionsIfDEPSChange(
@@ skipping 264 matching lines @@
     return ''
 
   def _PrintRevisionInfo(self, cl, info, depot=None):
     email_info = ''
     if not info['email'].startswith(info['author']):
       email_info = '\nEmail   : %s' % info['email']
     commit_link = self._GetViewVCLinkFromDepotAndHash(cl, depot)
     if commit_link:
       commit_info = '\nLink    : %s' % commit_link
     else:
-      commit_info = ('\nFailed to parse svn revision from body:\n%s' %
+      commit_info = ('\nFailed to parse SVN revision from body:\n%s' %
                      info['body'])
     print RESULTS_REVISION_INFO % {
         'subject': info['subject'],
         'author': info['author'],
         'email_info': email_info,
         'commit_info': commit_info,
         'cl': cl,
         'cl_date': info['date']
     }
 
@@ skipping 417 matching lines @@
 
   @staticmethod
   def _CreateCommandLineParser():
     """Creates a parser with bisect options.
 
     Returns:
       An instance of optparse.OptionParser.
     """
     usage = ('%prog [options] [-- chromium-options]\n'
              'Perform binary search on revision history to find a minimal '
-             'range of revisions where a peformance metric regressed.\n')
+             'range of revisions where a performance metric regressed.\n')
 
     parser = optparse.OptionParser(usage=usage)
 
     group = optparse.OptionGroup(parser, 'Bisect options')
     group.add_option('-c', '--command',
                      type='str',
                      help='A command to execute your performance test at' +
                      ' each point in the bisection.')
     group.add_option('-b', '--bad_revision',
                      type='str',
@@ skipping 147 matching lines @@
       if not opts.bad_revision:
         raise RuntimeError('missing required parameter: --bad_revision')
 
       if not opts.metric and opts.bisect_mode != BISECT_MODE_RETURN_CODE:
         raise RuntimeError('missing required parameter: --metric')
 
       if opts.gs_bucket:
         if not cloud_storage.List(opts.gs_bucket):
           raise RuntimeError('Invalid Google Storage: gs://%s' % opts.gs_bucket)
         if not opts.builder_host:
-          raise RuntimeError('Must specify try server hostname, when '
-                             'gs_bucket is used: --builder_host')
+          raise RuntimeError('Must specify try server host name using '
+                             '--builder_host when gs_bucket is used.')
         if not opts.builder_port:
-          raise RuntimeError('Must specify try server port number, when '
-                             'gs_bucket is used: --builder_port')
+          raise RuntimeError('Must specify try server port number using '
+                             '--builder_port when gs_bucket is used.')
       if opts.target_platform == 'cros':
         # Run sudo up front to make sure credentials are cached for later.
         print 'Sudo is required to build cros:'
         print
         bisect_utils.RunProcess(['sudo', 'true'])
 
         if not opts.cros_board:
           raise RuntimeError('missing required parameter: --cros_board')
 
         if not opts.cros_remote_ip:
@@ skipping 18 matching lines @@
         setattr(self, k, v)
     except RuntimeError, e:
       output_string = StringIO.StringIO()
       parser.print_help(file=output_string)
       error_message = '%s\n\n%s' % (e.message, output_string.getvalue())
       output_string.close()
       raise RuntimeError(error_message)
 
   @staticmethod
   def FromDict(values):
-    """Creates an instance of BisectOptions with the values parsed from a
-    .cfg file.
+    """Creates an instance of BisectOptions from a dictionary.
 
     Args:
       values: a dict containing options to set.
 
     Returns:
       An instance of BisectOptions.
     """
     opts = BisectOptions()
     for k, v in values.iteritems():
       assert hasattr(opts, k), 'Invalid %s attribute in BisectOptions.' % k
@@ skipping 70 matching lines @@
       # bugs. If you change this, please update the perf dashboard as well.
       bisect_utils.OutputAnnotationStepStart('Results')
     print 'Error: %s' % e.message
     if opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
   return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())