Fix lost suppressions with --tool=tsan_rv.

tools/valgrind/valgrind_test.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.
 
 # valgrind_test.py
 
 """Runs an exe through Valgrind and puts the intermediate files in a
 directory.
 """
@@ skipping 189 matching lines @@
       logging.error("Setup failed")
     end = datetime.datetime.now()
     seconds = (end - start).seconds
     hours = seconds / 3600
     seconds = seconds % 3600
     minutes = seconds / 60
     seconds = seconds % 60
     logging.info("elapsed time: %02d:%02d:%02d" % (hours, minutes, seconds))
     return retcode
 
+  def Run(self, args, module):
+    MODULES_TO_SANITY_CHECK = ["base"]
+
+    # TODO(timurrrr): this is a temporary workaround for http://crbug.com/47844
+    if self.ToolName() == "tsan" and common.IsMac():
+      MODULES_TO_SANITY_CHECK = []
+
+    check_sanity = module in MODULES_TO_SANITY_CHECK
+    return self.Main(args, check_sanity)
+
 
 class ValgrindTool(BaseTool):
   """Abstract class for running Valgrind tools.
 
   Always subclass this and implement ToolSpecificFlags() and
   ExtendOptionParser() for tool-specific stuff.
   """
   def __init__(self):
     super(ValgrindTool, self).__init__()
     self.RegisterOptionParserHook(ValgrindTool.ExtendOptionParser)
@@ skipping 644 matching lines @@
       return ThreadSanitizerRV1Windows()
     else:
       return ThreadSanitizerRV1Posix()
 
   def RV2Factory(self):
     if common.IsWindows():
       return ThreadSanitizerRV2Windows()
     else:
       return ThreadSanitizerRV2Posix()
 
+  def ToolName(self):
+    return "tsan"
+
   def Main(self, args, check_sanity):
     logging.info("Running a TSan + RaceVerifier test. For more information, " +
                  "see " + self.MORE_INFO_URL)
     cmd1 = self.RV1Factory()
     ret = cmd1.Main(args, check_sanity)
     # Verify race reports, if there are any.
     if ret == -1:
       logging.info("Starting pass 2 of 2. Running the same binary in " +
                    "RaceVerifier mode to confirm possible race reports.")
       logging.info("For more information, see " + self.MORE_INFO_URL)
       cmd2 = self.RV2Factory()
       ret = cmd2.Main(args, check_sanity)
     else:
       logging.info("No reports, skipping RaceVerifier second pass")
     logging.info("Please see " + self.MORE_INFO_URL + " for more information " +
                  "on RaceVerifier")
     return ret
 
+  def Run(self, args, module):
+   return self.Main(args, False)
+
 
 class ToolFactory:
   def Create(self, tool_name):
     if tool_name == "memcheck" and not common.IsWine():
       return Memcheck()
     if tool_name == "wine_memcheck" and common.IsWine():
       return Memcheck()
     if tool_name == "tsan":
       if common.IsWindows():
         return ThreadSanitizerWindows()
       else:
         return ThreadSanitizerPosix()
     if tool_name == "drmemory":
       return DrMemory()
     if tool_name == "tsan_rv":
       return RaceVerifier()
     try:
       platform_name = common.PlatformNames()[0]
     except common.NotImplementedError:
       platform_name = sys.platform + "(Unknown)"
     raise RuntimeError, "Unknown tool (tool=%s, platform=%s)" % (tool_name,
                                                                  platform_name)
 
-def RunTool(argv, module):
-  # TODO(timurrrr): customize optparse instead
-  tool_name = "memcheck"
-  args = argv[1:]
-  for arg in args:
-    if arg.startswith("--tool="):
-      tool_name = arg[7:]
-      args.remove(arg)
-      break
+def CreateTool(tool):
+  return ToolFactory().Create(tool)
 
-  tool = ToolFactory().Create(tool_name)
-  MODULES_TO_SANITY_CHECK = ["base"]
-
-  # TODO(timurrrr): this is a temporary workaround for http://crbug.com/47844
-  if tool_name == "tsan" and common.IsMac():
-    MODULES_TO_SANITY_CHECK = []
-
-  check_sanity = module in MODULES_TO_SANITY_CHECK
-  return tool.Main(args, check_sanity)
-
-if __name__ == "__main__":
-  if sys.argv.count("-v") > 0 or sys.argv.count("--verbose") > 0:
-    logging_utils.config_root(logging.DEBUG)
-  else:
-    logging_utils.config_root()
-  # TODO(timurrrr): valgrind tools may use -v/--verbose as well
-
-  ret = RunTool(sys.argv)
-  sys.exit(ret)
+if __name__ == '__main__':
+  logging.error(sys.argv[0] + " can not be run from command line")
+  sys.exit(1)