Adding ability to bisect recipe to bisect into dependency repos.

scripts/slave/recipe_modules/auto_bisect/perf_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.
 
 import json
+import tempfile
 import uuid
 
 from . import revision_state
 
 
 class PerfRevisionState(revision_state.RevisionState):
 
   """Contains the state and results for one revision in a perf bisect job."""
   def __init__(self, *args, **kwargs):
     super(PerfRevisionState, self).__init__(*args, **kwargs)
     self.values = []
     self.mean_value = None
     self.std_err = None
+    self._test_config = None
 
   def test_info(self):
     """Returns a dictionary with information that describes this test.
 
     It is meant to be used by the bisector to describe the test being run for
     each revision evaluated.
     """
     return {
         'command': self._test_config['command'],
         'metric': self._test_config['metric'],
     }
 
   def _read_test_results(self):
     """Gets the test results from GS and checks if the rev is good or bad."""
     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 keys:
     # 'mean', 'values', 'std_err'
     results = results['results']
     self.mean_value = results['mean']
     self.values = results['values']
     self.std_err = results['std_err']
     # We cannot test the goodness of the initial rev range.
     if self.bisector.good_rev != self and self.bisector.bad_rev != self:
       if self._check_revision_good():
         self.good = True
       else:
         self.bad = True
 
+  def _put_diff_file(self):

[qyearsley, 2015/02/22 20:37:55]

1. This might be improved with a docstring or a different name. Would
_write_deps_patch_file describe it? (I'm not sure.)

2. General question: Do you think it's better to say "diff file" or "patch
file"?
  In favor of "diff file":
    a) The man page for `patch` says "apply a diff file"
    b) The suffix below is .diff.
    c) It's the output of `diff` command.
  In favor of "patch file":
    a) RevisionState has a property called patch_file.
    b) It can be thought of as "a patch".
    c) "patch file" is a more common search query than "diff file", but "patch
file" is more common in India and "diff file" is more common in the US :-/ 
http://www.google.com/trends/explore#q=%22diff%20file%22%2C%20%22patch%20file%22

[RobertoCN, 2015/02/24 20:01:14]

Diff is the name of a tool to find and list differences between 2 files, also
the name of the produced output and its customary extension 'diff file/.diff'

Patch is the tool used to apply a transform to a file, typically a .diff file,
or the process of applying such transform, or the transform itself that is to be
applied.

I guess this is a hard question because our particular case is right were patch
and diff overlap. By diff'ing we generate a diff file that is used as a patch
file by the builder.

I guess it is slightly more correct to say diff if we are agnostic to the fact
that it will be used to modify a file. But if we see it as instructions to
modify a file regardless of how they were produced (think the DEPS.sha portion,
which is not created by diff'ing anything) then it makes a little more sense to
call it patch.

I guess the difference is more philosophical in nature than anything else.

I will rename the method for now, and aim for consistency in any future changes.

+    api = self.bisector.api
+    file_name = tempfile.gettempdir() + build_name + '.diff'
+    api.file.write('Saving diff patch for ' + self.revision_string,
+                   file_name, self.deps_patch)
+    return file_name
+
   def _request_build(self):
     """Posts a request to buildbot to build this revision and archive it."""
     # TODO: Rewrite using the trigger module.
-    # TODO: Send a diff patch when appropriate
     api = self.bisector.api
     bot_name = self.bisector.get_builder_bot_for_this_platform()
     if self.bisector.dummy_builds:
       self.build_job_name = self.commit_hash + '-build'
     else:
       self.build_job_name = uuid.uuid4().hex
+    if self.needs_patch:
+      self.patch_file = self._put_diff_file(build_job_name)
+    else:
+      self.patch_file = '/dev/null'
     try_cmd = [
         'try',
         '--bot=%s' % bot_name,
         '--revision=%s' % self.commit_hash,
         '--name=%s' % self.build_job_name,
         '--svn_repo=%s' % api.SVN_REPO_URL,
         '--diff',
-        '/dev/null',
+        self.patch_file,
     ]
-    api.m.git(*try_cmd, name='Requesting build for %s via git try.'
-              % str(self.commit_hash))
+    try:
+      api.m.git(*try_cmd, name='Requesting build for %s via git try.'
+                % str(self.commit_hash))
+    finally:
+      if self.patch_file != '/dev/null':
+        try:
+          api.step('cleaning up patch', 'rm', self.patch_file)
+        except api.step.StepFailure:
+          print 'Could not clean up ' + self.patch_file
 
   def _get_bisect_config_for_tester(self):
     """Copies the key-value pairs required by a tester bot to a new dict."""
     result = {}
     required_test_properties = {
         'truncate_percent',
         'metric',
         'max_time_minutes',
         'command',
         'repeat_count',
@@ skipping 93 matching lines @@
       True if this revision is closer to the initial good revision's value than
       to the initial bad revision's value. False otherwise.
     """
     # TODO: Reevaluate this approach
     bisector = self.bisector
     distance_to_good = abs(self.mean_value - bisector.good_rev.mean_value)
     distance_to_bad = abs(self.mean_value - bisector.bad_rev.mean_value)
     if distance_to_good < distance_to_bad:
       return True
     return False