Teach tools/valgrind about the output directory used by the Make build.

webkit/tools/layout_tests/layout_package/platform_utils_linux.py

 #!/usr/bin/python
 # Copyright (c) 2008 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.
 
 """Platform-specific utility methods shared by several scripts."""
 
 import os
 import re
 import signal
 import subprocess
 import sys
 import logging
 
 import google.path_utils
 
 # Distinguish the path_utils.py in this dir from google.path_utils.
 import path_utils as layout_package_path_utils
 
 # This will be a native path to the directory this file resides in.
 # It can either be relative or absolute depending how it's executed.
 THISDIR = os.path.dirname(os.path.abspath(__file__))
 def PathFromBase(*pathies):
   return google.path_utils.FindUpward(THISDIR, *pathies)
 
+def PathFromBuildResults(*pathies):
+  # FIXME(dkegel): use latest or warn if more than one found?
+  for dir in ["sconsbuild", "out", "xcodebuild"]:
+    try:
+      return google.path_utils.FindUpward(THISDIR, dir, *pathies)
+    except:
+      pass
+  raise google.path_utils.PathNotFound("Unable to find %s under any ancestor of %s" % (os.path.join(*pathies), THISDIR))
+
 def IsNonWindowsPlatformTargettingWindowsResults():
   """Returns true iff this platform is targetting Windows baseline, but isn't
   Windows. By default, in path_utils.py:ExpectedFilename, we expect platforms to
   be targetting Mac."""
   return True
 
 def GetTestListPlatformName():
   """Returns the name we use to identify the platform in the layout test
   test list files."""
   return "LINUX"
@@ skipping 119 matching lines @@
       os.kill(server_process.pid, signal.SIGTERM)
 
   def WDiffExecutablePath(self):
     """Path to the WDiff executable, which we assume is already installed and
        in the user's $PATH.
     """
     return 'wdiff'
 
   def ImageCompareExecutablePath(self, target):
     """Path to the image_diff binary."""
-    return PathFromBase('sconsbuild', target, 'image_diff')
+    return PathFromBuildResults(target, 'image_diff')
 
   def TestShellBinary(self):
     """The name of the binary for TestShell."""
     return 'test_shell'
 
   def TestShellBinaryPath(self, target):
     """Return the platform-specific binary path for our TestShell.
 
     Args:
       target: Build target mode (debug or release)
     """
 
     if target in ('Debug', 'Release'):
       try:
-        debug_path = PathFromBase('sconsbuild', 'Debug', self.TestShellBinary())
-        release_path = PathFromBase('sconsbuild', 'Release', \
+        debug_path = PathFromBuildResults('Debug', self.TestShellBinary())
+        release_path = PathFromBuildResults('Release', \
                                     self.TestShellBinary())
 
         debug_mtime = os.stat(debug_path).st_mtime
         release_mtime = os.stat(release_path).st_mtime
 
         if debug_mtime > release_mtime and target == 'Release' or \
            release_mtime > debug_mtime and target == 'Debug':
           logging.info('\x1b[31mWarning: you are not running the most ' + \
                        'recent test_shell binary. You need to pass ' + \
                        '--debug or not to select between Debug and ' + \
                        'Release.\x1b[0m')
       # This will fail if we don't have both a debug and release binary.
       # That's fine because, in this case, we must already be running the
       # most up-to-date one.
       except OSError:
         pass
       except google.path_utils.PathNotFound:
         pass
 
-    return PathFromBase('sconsbuild', target, self.TestShellBinary())
+    return PathFromBuildResults(target, self.TestShellBinary())
 
   def FuzzyMatchBinaryPath(self):
     """Return the path to the fuzzy matcher binary."""
     return PathFromBase('third_party', 'fuzzymatch', 'fuzzymatch')
 
   def TestListPlatformDir(self):
     """Return the platform-specific directory for where the test lists live"""
     return 'linux'
 
   def PlatformDir(self):
     """Returns the most specific directory name where platform-specific
     results live.
     """
     return 'chromium-linux'
 
   def PlatformNewResultsDir(self):
     """Returns the directory name in which to output newly baselined tests.
     """
     return self.PlatformDir()