Change PYTHONPATH handling in tools/valgrind so we can un-revert http://coder...

tools/valgrind/chrome_tests.py

 #!/usr/bin/python
 # Copyright (c) 2006-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.
 
 # chrome_tests.py
 
 ''' Runs various chrome tests through valgrind_test.py.'''
 
 import glob
 import logging
 import optparse
 import os
 import stat
 import sys
 
-import google.logging_utils
-import google.path_utils
+import logging_utils
+import path_utils
 
 import common
 import valgrind_test
 
 class TestNotFound(Exception): pass
 
 def Dir2IsNewer(dir1, dir2):
   if dir2 == None or not os.path.isdir(dir2):
     return False
   if dir1 == None or not os.path.isdir(dir1):
@@ skipping 48 matching lines @@
       "app": self.TestApp,              "app_unittests": self.TestApp,
     }
 
     if test not in self._test_list:
       raise TestNotFound("Unknown test: %s" % test)
 
     self._options = options
     self._args = args
     self._test = test
 
-    script_dir = google.path_utils.ScriptDir()
+    script_dir = path_utils.ScriptDir()
     # Compute the top of the tree (the "source dir") from the script dir (where
     # this script lives).  We assume that the script dir is in tools/valgrind/
     # relative to the top of the tree.
     self._source_dir = os.path.dirname(os.path.dirname(script_dir))
     # since this path is used for string matching, make sure it's always
     # an absolute Unix-style path
     self._source_dir = os.path.abspath(self._source_dir).replace('\\', '/')
     valgrind_test_script = os.path.join(script_dir, "valgrind_test.py")
     self._command_preamble = [valgrind_test_script,
                               "--source_dir=%s" % (self._source_dir)]
 
   def _DefaultCommand(self, module, exe=None, valgrind_test_args=None):
     '''Generates the default command array that most tests will use.'''
     module_dir = os.path.join(self._source_dir, module)
 
     # We need multiple data dirs, the current script directory and a module
     # specific one. The global suppression file lives in our directory, and the
     # module specific suppression file lives with the module.
-    self._data_dirs = [google.path_utils.ScriptDir()]
+    self._data_dirs = [path_utils.ScriptDir()]
 
     if module == "chrome":
       # unfortunately, not all modules have the same directory structure
       self._data_dirs.append(os.path.join(module_dir, "test", "data",
                                           "valgrind"))
     else:
       self._data_dirs.append(os.path.join(module_dir, "data", "valgrind"))
 
     if not self._options.build_dir:
       if common.IsWine():
@@ skipping 170 matching lines @@
     # to avoid valgrinding python.
     # Start by building the valgrind_test.py commandline.
     cmd = self._DefaultCommand("webkit")
     cmd.append("--trace_children")
     cmd.append("--indirect")
     cmd.append("--ignore_exit_code")
     # Now build script_cmd, the run_webkits_tests.py commandline
     # Store each chunk in its own directory so that we can find the data later
     chunk_dir = os.path.join("layout", "chunk_%05d" % chunk_num)
     test_shell = os.path.join(self._options.build_dir, "test_shell")
-    out_dir = os.path.join(google.path_utils.ScriptDir(), "latest")
+    out_dir = os.path.join(path_utils.ScriptDir(), "latest")
     out_dir = os.path.join(out_dir, chunk_dir)
     if os.path.exists(out_dir):
       old_files = glob.glob(os.path.join(out_dir, "*.txt"))
       for f in old_files:
         os.remove(f)
     else:
       os.makedirs(out_dir)
     script = os.path.join(self._source_dir, "webkit", "tools", "layout_tests",
                           "run_webkit_tests.py")
     script_cmd = ["python", script, "--run-singly", "-v",
@@ skipping 89 matching lines @@
   # My machine can do about 120 layout tests/hour in release mode.
   # Let's do 30 minutes worth per run.
   # The CPU is mostly idle, so perhaps we can raise this when
   # we figure out how to run them more efficiently.
   parser.add_option("-n", "--num_tests", default=60, type="int",
                     help="for layout tests: # of subtests per run.  0 for all.")
 
   options, args = parser.parse_args()
 
   if options.verbose:
-    google.logging_utils.config_root(logging.DEBUG)
+    logging_utils.config_root(logging.DEBUG)
   else:
-    google.logging_utils.config_root()
+    logging_utils.config_root()
 
   if not options.test or not len(options.test):
     parser.error("--test not specified")
 
   for t in options.test:
     tests = ChromeTests(options, args, t)
     ret = tests.Run()
     if ret: return ret
   return 0
 
 
 if __name__ == "__main__":
   ret = _main(sys.argv)
   sys.exit(ret)