Remove Wine + Valgrind code since nobody is working on it....

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 130 matching lines @@
     Full execution command-line provided by subclassers via proc."""
     logging.info("starting execution...")
 
     proc = self.ToolCommand()
 
     add_env = {
       "G_SLICE" : "always-malloc",
       "NSS_DISABLE_ARENA_FREE_LIST" : "1",
       "GTEST_DEATH_TEST_USE_FORK" : "1",
     }
-    if common.IsWine():
-      # TODO(timurrrr): Maybe we need it for TSan/Win too?
-      add_env["CHROME_ALLOCATOR"] = "winheap"
-
     for k,v in add_env.iteritems():
       logging.info("export %s=%s", k, v)
       os.putenv(k, v)
 
     return common.RunSubprocess(proc, self._timeout)
 
   def RunTestsAndAnalyze(self, check_sanity):
     exec_retcode = self.Execute()
     analyze_retcode = self.Analyze(check_sanity)
 
@@ skipping 80 matching lines @@
     parser.add_option("", "--num-callers",
                             dest="num_callers", default=30,
                             help="number of callers to show in stack traces")
     parser.add_option("", "--generate_dsym", action="store_true",
                           default=False,
                           help="Generate .dSYM file on Mac if needed. Slow!")
 
   def Setup(self, args):
     if not BaseTool.Setup(self, args):
       return False
-    if common.IsWine():
-      self.PrepareForTestWine()
-    elif common.IsMac():
+    if common.IsMac():
       self.PrepareForTestMac()
     return True
 
   def PrepareForTestMac(self):
     """Runs dsymutil if needed.
 
     Valgrind for Mac OS X requires that debugging information be in a .dSYM
     bundle generated by dsymutil.  It is not currently able to chase DWARF
     data into .o files like gdb does, so executables without .dSYM bundles or
     with the Chromium-specific "fake_dsym" bundles generated by
@@ skipping 46 matching lines @@
         # until the end, and is then killed, which is silly.
         common.RunSubprocess(dsymutil_command)
 
         if saved_test_command:
           os.rename(saved_test_command, test_command)
       else:
         logging.info("No real .dSYM for test_command.  Line numbers will "
                      "not be shown.  Either tell xcode to generate .dSYM "
                      "file, or use --generate_dsym option to this tool.")
 
-  def PrepareForTestWine(self):
-    """Set up the Wine environment.
-
-    We need to run some sanity checks, set up a Wine prefix, and make sure
-    wineserver is running by starting a dummy win32 program.
-    """
-    if not os.path.exists('/usr/share/ca-certificates/root_ca_cert.crt'):
-      logging.warning('WARNING: SSL certificate missing! SSL tests will fail.')
-      logging.warning('You need to run:')
-      logging.warning('sudo cp src/net/data/ssl/certificates/root_ca_cert.crt '
-                      '/usr/share/ca-certificates/')
-      logging.warning('sudo vi /etc/ca-certificates.conf')
-      logging.warning('  (and add the line root_ca_cert.crt)')
-      logging.warning('sudo update-ca-certificates')
-
-    # Shutdown the Wine server in case the last run got interrupted.
-    common.RunSubprocess([os.environ.get('WINESERVER'), '-k'])
-
-    # Yes, this can be dangerous if $WINEPREFIX is set incorrectly.
-    shutil.rmtree(os.environ.get('WINEPREFIX'), ignore_errors=True)
-
-    winetricks = os.path.join(self._source_dir, 'tools', 'valgrind',
-                              'wine_memcheck', 'winetricks')
-    common.RunSubprocess(['sh', winetricks,
-                          'nocrashdialog', 'corefonts', 'gecko'])
-    time.sleep(1)
-
-    # Start a dummy program like winemine so Valgrind won't run memcheck on
-    # the wineserver startup routine when it launches the test binary, which
-    # is slow and not interesting to us.
-    common.RunSubprocessInBackground([os.environ.get('WINE'), 'winemine'])
-    return
-
   def ToolCommand(self):
     """Get the valgrind command to run."""
     # Note that self._args begins with the exe to be run.
     tool_name = self.ToolName()
 
     # Construct the valgrind command.
     if self.SelfContained():
       proc = ["valgrind-%s.sh" % tool_name]
     else:
       proc = ["valgrind", "--tool=%s" % tool_name]
@@ skipping 26 matching lines @@
     if self._options.indirect:
       self.CreateBrowserWrapper(" ".join(proc), logfilename)
       proc = []
     proc += self._args
     return proc
 
   def ToolSpecificFlags(self):
     raise NotImplementedError, "This method should be implemented " \
                                "in the tool-specific subclass"
 
-  def Cleanup(self):
-    if common.IsWine():
-      # Shutdown the Wine server.
-      common.RunSubprocess([os.environ.get('WINESERVER'), '-k'])
-
   def CreateBrowserWrapper(self, command, logfiles):
     """The program being run invokes Python or something else
     that can't stand to be valgrinded, and also invokes
     the Chrome browser.  Set an environment variable to
     tell the program to prefix the Chrome commandline
     with a magic wrapper.  Build the magic wrapper here.
     """
     (fd, indirect_fname) = tempfile.mkstemp(dir=self.temp_dir,
                                             prefix="browser_wrapper.",
                                             text=True)
@@ skipping 481 matching lines @@
     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():
+    if tool_name == "memcheck":
       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 CreateTool(tool):
   return ToolFactory().Create(tool)
 
 if __name__ == '__main__':
   logging.error(sys.argv[0] + " can not be run from command line")
   sys.exit(1)