Fix lost suppressions with --tool=tsan_rv.

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
@@ skipping 67 matching lines @@
 
     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)]
+    self._command_preamble = ["--source_dir=%s" % (self._source_dir)]
 
-  def _DefaultCommand(self, module, exe=None, valgrind_test_args=None):
+  def _DefaultCommand(self, tool, 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 = [path_utils.ScriptDir()]
 
     if module == "chrome":
       # unfortunately, not all modules have the same directory structure
@@ skipping 12 matching lines @@
           os.path.join(self._source_dir, "sconsbuild", "Debug"),
           os.path.join(self._source_dir, "out", "Debug"),
         ]
         if exe:
           self._options.build_dir = FindDirContainingNewestFile(dirs, exe)
         else:
           self._options.build_dir = FindNewestDir(dirs)
 
     cmd = list(self._command_preamble)
     for directory in self._data_dirs:
-      tool_name = self._options.valgrind_tool
+      tool_name = tool.ToolName();
       suppression_file = os.path.join(directory,
           "%s/suppressions.txt" % tool_name)
       if os.path.exists(suppression_file):
         cmd.append("--suppressions=%s" % suppression_file)
       # Platform specific suppression
       for suppression_platform in common.PlatformNames():
         suppression_file_platform = \
             os.path.join(directory,
                 '%s/suppressions_%s.txt' % (tool_name, suppression_platform))
         if os.path.exists(suppression_file_platform):
           cmd.append("--suppressions=%s" % suppression_file_platform)
 
-    cmd.append("--tool=%s" % self._options.valgrind_tool)
     if self._options.valgrind_tool_flags:
       cmd += self._options.valgrind_tool_flags.split(" ")
     if valgrind_test_args != None:
       for arg in valgrind_test_args:
         cmd.append(arg)
     if exe:
       if common.IsWine():
         cmd.append(os.environ.get('WINE'))
         exe = exe + '.exe'
       cmd.append(os.path.join(self._options.build_dir, exe))
       # Valgrind runs tests slowly, so slow tests hurt more; show elapased time
       # so we can find the slowpokes.
       cmd.append("--gtest_print_time")
     if self._options.gtest_repeat:
       cmd.append("--gtest_repeat=%s" % self._options.gtest_repeat)
     return cmd
 
   def Run(self):
     ''' Runs the test specified by command-line argument --test '''
     logging.info("running test %s" % (self._test))
     return self._test_list[self._test](self)
 
-  def _ReadGtestFilterFile(self, name, cmd):
+  def _ReadGtestFilterFile(self, tool, name, cmd):
     '''Read a file which is a list of tests to filter out with --gtest_filter
     and append the command-line option to cmd.
     '''
     filters = []
     for directory in self._data_dirs:
       gtest_filter_files = [
           os.path.join(directory, name + ".gtest.txt"),
           os.path.join(directory, name + ".gtest-%s.txt" % \
-              self._options.valgrind_tool)]
+              tool.ToolName())]
       for platform_suffix in common.PlatformNames():
         gtest_filter_files += [
           os.path.join(directory, name + ".gtest_%s.txt" % platform_suffix),
           os.path.join(directory, name + ".gtest-%s_%s.txt" % \
-              (self._options.valgrind_tool, platform_suffix))]
+              (tool.ToolName(), platform_suffix))]
       for filename in gtest_filter_files:
         if os.path.exists(filename):
           logging.info("reading gtest filters from %s" % filename)
           f = open(filename, 'r')
           for line in f.readlines():
             if line.startswith("#") or line.startswith("//") or line.isspace():
               continue
             line = line.rstrip()
             test_prefixes = ["FLAKY", "FAILS"]
             for p in test_prefixes:
@@ skipping 13 matching lines @@
         gtest_filter += ":"
         if gtest_filter.find("-") < 0:
           gtest_filter += "-"
       else:
         gtest_filter = "-"
       gtest_filter += ":".join(filters)
     if gtest_filter:
       cmd.append("--gtest_filter=%s" % gtest_filter)
 
   def SimpleTest(self, module, name, valgrind_test_args=None, cmd_args=None):
-    cmd = self._DefaultCommand(module, name, valgrind_test_args)
-    self._ReadGtestFilterFile(name, cmd)
+    tool = valgrind_test.CreateTool(self._options.valgrind_tool)
+    cmd = self._DefaultCommand(tool, module, name, valgrind_test_args)
+    self._ReadGtestFilterFile(tool, name, cmd)
     if cmd_args:
       cmd.extend(["--"])
       cmd.extend(cmd_args)
 
     # Sets LD_LIBRARY_PATH to the build folder so external libraries can be
     # loaded.
     if (os.getenv("LD_LIBRARY_PATH")):
       os.putenv("LD_LIBRARY_PATH", "%s:%s" % (os.getenv("LD_LIBRARY_PATH"),
                                               self._options.build_dir))
     else:
       os.putenv("LD_LIBRARY_PATH", self._options.build_dir)
-    return valgrind_test.RunTool(cmd, module)
+    return tool.Run(cmd, module)
 
   def TestBase(self):
     return self.SimpleTest("base", "base_unittests")
 
   def TestBrowser(self):
     return self.SimpleTest("chrome", "browser_tests")
 
   def TestGURL(self):
     return self.SimpleTest("chrome", "googleurl_unittests")
 
   def TestCourgette(self):
     return self.SimpleTest("courgette", "courgette_unittests")
 
   def TestMedia(self):
     return self.SimpleTest("chrome", "media_unittests")
 
   def TestNotifier(self):
     return self.SimpleTest("chrome", "notifier_unit_tests")
-  
+
   def TestPrinting(self):
     return self.SimpleTest("chrome", "printing_unittests")
 
   def TestRemoting(self):
     return self.SimpleTest("chrome", "remoting_unittests")
 
   def TestIpc(self):
     return self.SimpleTest("ipc", "ipc_tests",
                            valgrind_test_args=["--trace_children"])
 
@@ skipping 40 matching lines @@
     # list of tests.  Wrap around to beginning of list at end.
     # If chunk_size is zero, run all tests in the list once.
     # If a text file is given as argument, it is used as the list of tests.
     #
     # Build the ginormous commandline in 'cmd'.
     # It's going to be roughly
     #  python valgrind_test.py ... python run_webkit_tests.py ...
     # but we'll use the --indirect flag to valgrind_test.py
     # to avoid valgrinding python.
     # Start by building the valgrind_test.py commandline.
-    cmd = self._DefaultCommand("webkit")
+    tool = valgrind_test.CreateTool(self._options.valgrind_tool)
+    cmd = self._DefaultCommand(tool, "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(path_utils.ScriptDir(), "latest")
     out_dir = os.path.join(out_dir, chunk_dir)
     if os.path.exists(out_dir):
@@ skipping 15 matching lines @@
     if self._options.build_dir.endswith("Debug"):
       script_cmd.append("--debug");
     if (chunk_size > 0):
       script_cmd.append("--run-chunk=%d:%d" % (chunk_num, chunk_size))
     if len(self._args):
       # if the arg is a txt file, then treat it as a list of tests
       if os.path.isfile(self._args[0]) and self._args[0][-4:] == ".txt":
         script_cmd.append("--test-list=%s" % self._args[0])
       else:
         script_cmd.extend(self._args)
-    self._ReadGtestFilterFile("layout", script_cmd)
+    self._ReadGtestFilterFile(tool, "layout", script_cmd)
     # Now run script_cmd with the wrapper in cmd
     cmd.extend(["--"])
     cmd.extend(script_cmd)
-    return valgrind_test.RunTool(cmd, "layout")
+    return tool.Run(cmd, "layout")
 
   def TestLayout(self):
     # A "chunk file" is maintained in the local directory so that each test
     # runs a slice of the layout tests of size chunk_size that increments with
     # each run.  Since tests can be added and removed from the layout tests at
     # any time, this is not going to give exact coverage, but it will allow us
     # to continuously run small slices of the layout tests under valgrind rather
     # than having to run all of them in one shot.
     chunk_size = self._options.num_tests
     if (chunk_size == 0):
@@ skipping 100 matching lines @@
   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)