Revert of Cross-repo recipe package system.

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
+from infra.libs.infra_types import freeze, thaw
 from recipe_engine import recipe_api
 from recipe_engine import util as recipe_util
 
 from . import builders
 from . import steps
 
 
 class ChromiumTestsApi(recipe_api.RecipeApi):
   def __init__(self, *args, **kwargs):
     super(ChromiumTestsApi, self).__init__(*args, **kwargs)
@@ skipping 126 matching lines @@
     test_spec_file = bot_config.get('testing', {}).get(
         'test_spec_file', '%s.json' % mastername)
 
     # TODO(phajdan.jr): Bots should have no generators instead.
     if bot_config.get('disable_tests'):
       return {}
     return self.read_test_spec(self.m, test_spec_file)
 
   def get_master_dict_with_dynamic_tests(
       self, mastername, buildername, test_spec, scripts_compile_targets):
-    # We manually thaw the path to the elements we are modifying, since the
-    # builders are frozen.
-    master_dict = dict(self.builders[mastername])
-    builders = master_dict['builders'] = dict(master_dict['builders'])
-    bot_config = builders[buildername]
-    for loop_buildername in builders:
-      builder_dict = builders[loop_buildername] = (
-          dict(builders[loop_buildername]))
-      builders[loop_buildername]['tests'] = (
-          self.generate_tests_from_test_spec(
-              self.m, test_spec, builder_dict, loop_buildername, mastername,
-              # TODO(phajdan.jr): Get enable_swarming value from builder_dict.
-              # Above should remove the need to get bot_config and buildername
-              # in this method.
-              bot_config.get('enable_swarming', False),
-              scripts_compile_targets, builder_dict.get('test_generators', [])
-          ))
+    # Make an independent copy so that we don't overwrite global state
+    # with updates made dynamically based on the test specs.
+    master_dict = thaw(self.builders.get(mastername, {}))
+    bot_config = master_dict.get('builders', {}).get(buildername)
+
+    for loop_buildername, builder_dict in master_dict.get(
+        'builders', {}).iteritems():
+      builder_dict['tests'] = self.generate_tests_from_test_spec(
+          self.m, test_spec, builder_dict,
+          loop_buildername, mastername,
+          # TODO(phajdan.jr): Get enable_swarming value from builder_dict.
+          # Above should remove the need to get bot_config and buildername
+          # in this method.
+          bot_config.get('enable_swarming', False),
+          scripts_compile_targets, builder_dict.get('test_generators', []))
 
     return freeze(master_dict)
 
   def prepare_checkout(self, mastername, buildername):
     bot_config = self.get_bot_config(mastername, buildername)
 
     update_step = self.ensure_checkout(mastername, buildername)
 
     self.set_up_swarming(mastername, buildername)
     self.runhooks(mastername, buildername, update_step)
@@ skipping 11 matching lines @@
         mastername, buildername, test_spec, scripts_compile_targets)
 
     if self.m.chromium.c.lto:
       self.m.chromium.download_lto_plugin()
 
     return update_step, master_dict, test_spec
 
   def generate_tests_from_test_spec(self, api, test_spec, builder_dict,
       buildername, mastername, enable_swarming, scripts_compile_targets,
       generators):
-    tests = builder_dict.get('tests', ())
+    tests = builder_dict.get('tests', [])
     # TODO(phajdan.jr): Switch everything to scripts generators and simplify.
     for generator in generators:
       tests = (
-          tuple(generator(api, mastername, buildername, test_spec,
+          list(generator(api, mastername, buildername, test_spec,
                          enable_swarming=enable_swarming,
                          scripts_compile_targets=scripts_compile_targets)) +
           tests)
     return tests
 
   def read_test_spec(self, api, test_spec_file):
     test_spec_path = api.path['checkout'].join('testing', 'buildbot',
                                                test_spec_file)
     test_spec_result = api.json.read(
         'read test spec',
@@ skipping 327 matching lines @@
       self.m.gclient.c.revisions[solution] = str(
           bot_update_json['properties'][revision])
     self.m.bot_update.ensure_checkout(
         force=True, patch=False, update_presentation=False)
     self.m.chromium.runhooks(name='runhooks (without patch)')
 
   def run_tests_and_deapply_as_needed(self, mastername, api, tests,
                                       bot_update_step):
     def deapply_patch_fn(failing_tests):
       self.deapply_patch(bot_update_step)
-      compile_targets = list(itertools.chain(
+      compile_targets = list(self.m.itertools.chain(
           *[t.compile_targets(api) for t in failing_tests]))
       if compile_targets:
         # Remove duplicate targets.
         compile_targets = sorted(set(compile_targets))
         failing_swarming_tests = [
             t.isolate_target for t in failing_tests if t.uses_swarming]
         if failing_swarming_tests:
           self.m.isolate.clean_isolated_files(self.m.chromium.output_dir)
         self.run_mb_and_compile(compile_targets, failing_swarming_tests,
                                 ' (without patch)')
@@ skipping 187 matching lines @@
   def get_compile_targets_for_scripts(self):
     return self.m.python(
         name='get compile targets for scripts',
         script=self.m.path['checkout'].join(
             'testing', 'scripts', 'get_compile_targets.py'),
         args=[
             '--output', self.m.json.output(),
             '--',
         ] + self.get_common_args_for_scripts(),
         step_test_data=lambda: self.m.json.test_api.output({}))