Set update gclient config with override deps.

scripts/slave/recipe_modules/auto_bisect/revision_state.py

 # Copyright 2015 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.
 
 """An interface for holding state and result of revisions in a bisect job.
 
 When implementing support for tests other than perf, one should extend this
 class so that the bisect module and recipe can use it.
 
 See perf_revision_state for an example.
@@ skipping 54 matching lines @@
     self.next_revision = None
     self.previous_revision = None
     self.job_name = None
     self.patch_file = None
     self.deps_revision = None
     self.depot_name = depot_name or self.bisector.base_depot
     self.depot = depot_config.DEPOT_DEPS_NAME[self.depot_name]
     self.commit_hash = str(commit_hash)
     self._rev_str = None
     self.base_revision = base_revision
+    self.top_revision = self
+    # The difference between revsion overrides and revsion ladder is that the
+    # former is indexed by paths, e.g. 'src/third_party/skia' and the latter is
+    # indexed by depot name, e.g. 'skia'.
     self.revision_overrides = {}
+    self.revision_ladder = {self.depot_name: self.commit_hash}
     self.build_id = None
     if self.base_revision:
       assert self.base_revision.deps_file_contents
       self.needs_patch = True
       self.revision_overrides[self.depot['src']] = self.commit_hash
+      # To allow multiple nested levels, we go to the topmost revision.
+      while self.top_revision.base_revision:
+        self.top_revision = self.top_revision.base_revision
+        # We want to carry over any overrides from the base revision(s) without
+        # overwriting any overrides specified at the self level.
+        self.revision_ladder[self.top_revision.depot_name] = (
+            self.top_revision.commit_hash)
+        self.revision_overrides = dict(
+            self.top_revision.revision_overrides.items() +
+            self.revision_overrides.items())
       self.deps_patch, self.deps_file_contents = self.bisector.make_deps_patch(
           self.base_revision, self.base_revision.deps_file_contents,
           self.depot, self.commit_hash)
       self.deps_sha = hashlib.sha1(self.deps_patch).hexdigest()
       self.deps_sha_patch = self.bisector.make_deps_sha_file(self.deps_sha)
       self.deps = dict(base_revision.deps)
       self.deps[self.depot_name] = self.commit_hash
     else:
       self.needs_patch = False
     self.build_url = self.bisector.get_platform_gs_prefix() + self._gs_suffix()
@@ skipping 206 matching lines @@
     result = api.gsutil_file_exists(self.test_results_url)
     if self.bisector.dummy_builds:
       return self.in_progress
     return result  # pragma: no cover
 
   def _gs_suffix(self):
     """Provides the expected right half of the build filename.
 
     This takes into account whether the build has a deps patch.
     """
-    top_revision = self
-    while top_revision.base_revision:
-      top_revision = top_revision.base_revision
-    name_parts = [top_revision.commit_hash]
+    name_parts = [self.top_revision.commit_hash]
     if self.needs_patch:
       name_parts.append(self.deps_sha)
     return '%s.zip' % '_'.join(name_parts)
 
   def _read_test_results(self, check_revision_goodness=True):
     """Gets the test results from GS and checks if the rev is good or bad."""
     test_results = self._get_test_results()
     # Results will contain the keys 'results' and 'output' where output is the
     # stdout of the command, and 'results' is itself a dict with the key
     # 'values' unless the test failed, in which case 'results' will contain
@@ skipping 41 matching lines @@
         check_revision_goodness):
       if self._check_revision_good():
         self.good = True
       else:
         self.bad = True
 
   def _request_build(self):
     """Posts a request to buildbot to build this revision and archive it."""
     api = self.bisector.api
     bot_name = self.bisector.get_builder_bot_for_this_platform()
-
-    # To allow multiple nested levels, we go to the topmost revision.
-    top_revision = self
-    while top_revision.base_revision:
-      top_revision = top_revision.base_revision
-      # We want to carry over any overrides from the base revision(s) without
-      # overwriting any overrides specified at the self level.
-      self.revision_overrides = dict(top_revision.revision_overrides.items() +
-                                     self.revision_overrides.items())
-
     operation_id = 'dummy' if self.bisector.dummy_tests else uuid.uuid4().hex
     build_details = {
         'bucket': 'master.' + api.m.properties['mastername'],
         'parameters': {
             'builder_name': bot_name,
             'properties': {
-                'parent_got_revision': top_revision.commit_hash,
+                'parent_got_revision': self.top_revision.commit_hash,
                 'clobber': True,
                 'build_archive_url': self.build_url,
             },
         },
         'client_operation_id': operation_id
     }
     if self.revision_overrides:
       build_details['parameters']['properties']['deps_revision_overrides'] = \
           self.revision_overrides
 
@@ skipping 30 matching lines @@
 
     If local testing is enabled (i.e. director/tester merged) then
     the test will be run on the same machine. Otherwise, this posts
     a request to buildbot to download and perf-test this build.
     """
     if self.bisector.bisect_config.get('dummy_job_names'):
       self.job_name = self.commit_hash + '-test'
     else:  # pragma: no cover
       self.job_name = uuid.uuid4().hex
     api = self.bisector.api
-    # Stores revision map for different repos eg, android-chrome, src, v8 etc.
-    revision_ladder = {}
-    top_revision = self
-    revision_ladder[top_revision.depot_name] = top_revision.commit_hash
-    while top_revision.base_revision:  # pragma: no cover
-      revision_ladder[top_revision.depot_name] = top_revision.commit_hash
-      top_revision = top_revision.base_revision
     perf_test_properties = {
         'builder_name': self.bisector.get_perf_tester_name(),
         'properties': {
-            'revision': top_revision.commit_hash,
-            'parent_got_revision': top_revision.commit_hash,
+            'revision': self.top_revision.commit_hash,
+            'parent_got_revision': self.top_revision.commit_hash,
             'parent_build_archive_url': self.build_url,
             'bisect_config': self._get_bisect_config_for_tester(),
             'job_name': self.job_name,
-            'revision_ladder': revision_ladder,
+            'revision_ladder': self.revision_ladder,
+            'deps_revision_overrides': self.revision_overrides,
         },
     }
     self.test_results_url = (self.bisector.api.GS_RESULTS_URL +
                              self.job_name + '.results')
     if (api.m.bisect_tester.local_test_enabled() or
         self.bisector.internal_bisect):  # pragma: no cover
       skip_download = self.bisector.last_tested_revision == self
       self.bisector.last_tested_revision = self
       overrides = perf_test_properties['properties']
       api.run_local_test_run(overrides, skip_download=skip_download)
@@ skipping 108 matching lines @@
     else:
       next_revision_to_test.retest()
 
   def __repr__(self):
     if self.overall_return_code is not None:
       return ('RevisionState(rev=%s, values=%r, overall_return_code=%r, '
               'std_dev=%r)') % (self.revision_string(), self.values,
                                 self.overall_return_code, self.std_dev)
     return ('RevisionState(rev=%s, values=%r, mean_value=%r, std_dev=%r)' % (
         self.revision_string(), self.values, self.mean_value, self.std_dev))