Drop unwanted dependencies on chromium_tests recipe module

scripts/slave/recipe_modules/chromium_tests/api.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 contextlib
 import copy
 import itertools
 import json
 
 from recipe_engine.types import freeze
@@ skipping 12 matching lines @@
 ]
 
 
 class ChromiumTestsApi(recipe_api.RecipeApi):
   def __init__(self, *args, **kwargs):
     super(ChromiumTestsApi, self).__init__(*args, **kwargs)
     self._builders = {}
     self.add_builders(builders.BUILDERS)
     self._precommit_mode = False
 
-    # Keep track of working directory (which contains the checkout).
-    # None means "default value".
-    self._working_dir = None
-
   @property
   def builders(self):
     return self._builders
 
   @property
   def steps(self):
     return steps
 
   @property
   def trybots(self):
@@ skipping 76 matching lines @@
       # (3) 'HEAD' for forced builds with unspecified 'revision'.
       # TODO(machenbach): Use parent_got_cr_revision on testers with component
       # builds to match also the chromium revision from the builder.
       component_rev = self.m.properties.get('revision') or 'HEAD'
       if bot_type == 'tester':
         component_rev = self.m.properties.get(
             'parent_got_revision', component_rev)
       dep = bot_config.get('set_component_rev')
       self.m.gclient.c.revisions[dep['name']] = dep['rev_str'] % component_rev
 
-  def get_checkout_dir(self, bot_config):
-    try:
-      builder_cache = self.m.path['builder_cache']
-    except KeyError:  # no-op if builder cache is not set up.
-      return None
-    else:
-      sanitized_buildername = ''.join(
-          c if c.isalnum() else '_' for c in self.m.properties['buildername'])
-      checkout_dir = builder_cache.join(
-          bot_config.get('checkout_dir', sanitized_buildername))
-      self.m.shutil.makedirs('checkout path', checkout_dir)
-      return checkout_dir
+  # TODO(phajdan.jr): fix callers and remove chromium_tests.get_checkout_dir.
+  def get_checkout_dir(self, bot_config):  # pragma: no cover
+    return self.m.chromium_checkout.get_checkout_dir(bot_config)
 
+  # TODO(phajdan.jr): fix callers and remove chromium_tests.ensure_checkout.
   def ensure_checkout(self, bot_config, root_solution_revision=None,
                       force=False):
-    if self.m.platform.is_win:
-      self.m.chromium.taskkill()
-
-    kwargs = {}
-    self._working_dir = self.get_checkout_dir(bot_config)
-    if self._working_dir:
-      kwargs['cwd'] = self._working_dir
-
-    # Bot Update re-uses the gclient configs.
-    update_step = self.m.bot_update.ensure_checkout(
-        patch_root=bot_config.get('patch_root'),
-        root_solution_revision=root_solution_revision,
-        clobber=bot_config.get('clobber', False),
-        force=force, **kwargs)
-    assert update_step.json.output['did_run']
-    # HACK(dnj): Remove after 'crbug.com/398105' has landed
-    self.m.chromium.set_build_properties(update_step.json.output['properties'])
-
-    return update_step
+    return self.m.chromium_checkout.ensure_checkout(  # pragma: no cover
+        bot_config, root_solution_revision, force)
 
   def set_up_swarming(self, bot_config):
     if not bot_config.get('enable_swarming'):
       return
     self.m.isolate.set_isolate_environment(self.m.chromium.c)
     self.m.swarming.check_client_version()
     for key, value in bot_config.get('swarming_dimensions', {}).iteritems():
       self.m.swarming.set_default_dimension(key, value)
 
   def runhooks(self, update_step):
@@ skipping 10 matching lines @@
   # TODO(phajdan.jr): remove create_bot_db_from_master_dict. It adds another
   # entry point to _add_master_dict_and_test_spec which can really complicate
   # things.
   def create_bot_db_from_master_dict(self, mastername, master_dict):
     bot_db = bdb_module.BotConfigAndTestDB()
     bot_db._add_master_dict_and_test_spec(mastername, master_dict, {})
     return bot_db
 
   def prepare_checkout(self, bot_config, root_solution_revision=None,
                        force=False):
-    update_step = self.ensure_checkout(
+    update_step = self.m.chromium_checkout.ensure_checkout(
         bot_config, root_solution_revision, force=force)
 
     if (self.m.chromium.c.compile_py.compiler and
         'goma' in self.m.chromium.c.compile_py.compiler):
       self.m.chromium.ensure_goma(canary=bot_config.get('goma_canary', False))
 
     self.set_up_swarming(bot_config)
     self.runhooks(update_step)
 
     bot_db = bdb_module.BotConfigAndTestDB()
@@ skipping 329 matching lines @@
   def _make_legacy_build_url(self, master_config, mastername):
     return self.m.archive.legacy_download_url(
                master_config.get('build_gs_bucket'),
                extra_url_components=(
                    None if mastername.startswith('chromium.perf')
                    else self.m.properties['mastername']))
 
   @contextlib.contextmanager
   def wrap_chromium_tests(self, bot_config, tests=None):
     context = {
-        'cwd': self._working_dir,
+        'cwd': self.m.chromium_checkout.working_dir,
         'env': self.m.chromium.get_env(),
     }
     with self.m.step.context(context):
       bot_type = bot_config.get('bot_type', 'builder_tester')
 
       if bot_type in ('tester', 'builder_tester'):
         isolated_targets = [
             t.isolate_target(self.m) for t in tests if t.uses_swarming]
         if isolated_targets:
           self.m.isolate.find_isolated_tests(self.m.chromium.output_dir)
@@ skipping 81 matching lines @@
     # is also imporant that we do not assume that corresponding revision is
     # stored in the 'got_revision' as some gclient configs change the default
     # mapping for their own purposes.
     first_solution_name = self.m.gclient.c.solutions[0].name
     rev_property = self.m.gclient.c.got_revision_mapping[first_solution_name]
     self.m.gclient.c.revisions[first_solution_name] = str(
         bot_update_json['properties'][rev_property])
     self._resolve_fixed_revisions(bot_update_json)
 
     kwargs = {}
-    if self._working_dir:
-      kwargs['cwd'] = self._working_dir
+    if self.m.chromium_checkout.working_dir:
+      kwargs['cwd'] = self.m.chromium_checkout.working_dir
 
     self.m.bot_update.ensure_checkout(
         force=True, patch=False, update_presentation=False, **kwargs)
     self.m.chromium.runhooks(name='runhooks (without patch)')
 
   def run_tests_on_tryserver(self, bot_config, api, tests, bot_update_step,
                              affected_files, mb_mastername=None,
                              mb_buildername=None):
     def deapply_patch_fn(failing_tests):
       self.deapply_patch(bot_update_step)
@@ skipping 26 matching lines @@
       if deapply_patch:
         self.m.test_utils.determine_new_failures(api, tests, deapply_patch_fn)
       else:
         failing_tests = self.m.test_utils.run_tests_with_patch(api, tests)
         if failing_tests:
           self.m.python.failing_step(
               'test results',
               'TESTS FAILED; retries without patch disabled (%s)'
                   % deapply_patch_reason)
 
+  # TODO(phajdan.jr): fix callers and remove get_files_affected_by_patch.
   def get_files_affected_by_patch(self, relative_to='src/', cwd=None):
-    """Returns list of POSIX paths of files affected by patch for "analyze".
-
-    Paths are relative to `relative_to` which for analyze should be 'src/'.
-    """
-    patch_root = self.m.gclient.calculate_patch_root(
-        self.m.properties.get('patch_project'))
-    if not cwd:
-      cwd = self._working_dir.join(patch_root) if self._working_dir else None
-    files = self.m.tryserver.get_files_affected_by_patch(patch_root, cwd=cwd)
-    for i, path in enumerate(files):
-      path = str(path)
-      assert path.startswith(relative_to)
-      files[i] = path[len(relative_to):]
-    return files
+    return self.m.chromium_checkout.get_files_affected_by_patch(  # pragma: no cover
+        relative_to, cwd)
 
   # TODO(phajdan.jr): fix callers and remove chromium_tests.configure_swarming.
   def configure_swarming(self, project_name, precommit, mastername=None):
     return self.m.chromium_swarming.configure_swarming(  # pragma: no cover
         project_name, precommit, mastername)
 
   def _build_gs_archive_url(self, mastername, master_config, buildername):
     """Returns the archive URL to pass to self.m.archive.zip_and_upload_build.
 
     Most builders on most masters use a standard format for the build archive
@@ skipping 96 matching lines @@
 
     if not tests:
       return
 
     api.chromium_swarming.configure_swarming(
         'chromium', precommit=False, mastername=mastername)
     test_runner = api.chromium_tests.create_test_runner(
         api, tests, serialize_tests=bot_config.get('serialize_tests'))
     with api.chromium_tests.wrap_chromium_tests(bot_config, tests):
       test_runner()