Update chrome_tests.sh to run DrMemory from Cygwin

tools/valgrind/valgrind_test.py

 #!/usr/bin/python
 # Copyright (c) 2011 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.
 """
 
 import datetime
 import glob
 import logging
 import optparse
 import os
+import platform
 import re
 import shutil
 import stat
 import subprocess
 import sys
 import tempfile
 
 import common
 
 import drmemory_analyze
@@ skipping 672 matching lines @@
 
   def Analyze(self, check_sanity=False):
     filenames = glob.glob(self.log_dir + "/tsan.*")
     analyzer = tsan_analyze.TsanAnalyzer(self._source_dir)
     ret = analyzer.Report(filenames, check_sanity)
     if ret != 0:
       logging.info(self.INFO_MESSAGE)
     return ret
 
 
+def _Cygpath(path):

[Timur Iskhodzhanov, 2011/11/10 11:52:49]

maybe this should me moved to tools\valgrind\common.py

[Alexander Potapenko, 2011/11/10 12:12:13]

Am I right you're this function is called on every platform, even non-Cygwin?
Then it should be named accordingly (I can't think of anything better than
_NormalizePath)

[Reid Kleckner (google), 2011/11/10 14:00:30]

It's actually fairly specific to DrMemory, I think, but I suppose you could
generalize it to cover any native Windows tool that you want to invoke from
Cygwin.  None of the other tools in this file support Windows, though, right?

I'll actually make it a private static method on the DrMemory class.  If and
when there are other Windows tools we can move it back out.

[Timur Iskhodzhanov, 2011/11/10 14:03:19]

The only reason for doing your CL is to support running devenv-built binaries
under DrMemory from Cygwin, right?
Did you try tools\valgrind\chrome_tests.bat in Cygwin?
Wrong: TSan is working fine on Windows.
No-one ever told me it's not working from Cygwin, not sure if it's very needed
for DrM either.
See above

[Reid Kleckner (google), 2011/11/10 14:19:09]

No.  Because I'm using Cygwin, depot_tools uses those binaries instead of
installing it's own.  Therefore, both chrome_tests.sh and chrome_tests.bat
invoke /usr/bin/python, which uses POSIX style paths.  drmemory.exe expects
Windows style paths, not the app.
Yes, it fails to import logging_utils because Cygwin Python doesn't like the
backslashes in PYTHONPATH.  I'm better at bash than cmd, so I added drmemory
support to chrome_tests.sh instead of having chrome_tests.bat conditionally
invoke cygpath.

(chrome_tests.bat works fine from a cmd prompt, btw)
OK, I'll see if I can't get tsan running on Cygwin.

+  """If we're using Cygwin Python, turn the path into a Windows path.
+
+  Don't turn forward slashes into backslashes for easier copy-pasting and
+  escaping.
+  """
+  if path[0] == "/" and "cygwin" in platform.system().lower():
+    p = subprocess.Popen(["cygpath", "-m", path],
+                         stdout=subprocess.PIPE,
+                         stderr=subprocess.PIPE)
+    (out, err) = p.communicate()
+    if err:
+      logging.warning("WARNING: cygpath error: %s", err)
+    return out.strip()
+  else:
+    return path
+
+
 class DrMemory(BaseTool):
   """Dr.Memory
   Dynamic memory error detector for Windows.
 
   http://dev.chromium.org/developers/how-tos/using-drmemory
   It is not very mature at the moment, some things might not work properly.
   """
 
   def __init__(self, handle_uninits_and_leaks):
     super(DrMemory, self).__init__()
@@ skipping 72 matching lines @@
       drconfig_retcode = common.RunSubprocess(drconfig_cmd, self._timeout)
       if drconfig_retcode:
         logging.error("Configuring whether to follow python children failed " \
                       "with %d.", drconfig_retcode)
         raise RuntimeError, "Configuring python children failed "
 
     suppression_count = 0
     for suppression_file in self._options.suppressions:
       if os.path.exists(suppression_file):
         suppression_count += 1
-        proc += ["-suppress", suppression_file]
+        proc += ["-suppress", _Cygpath(suppression_file)]
 
     if not suppression_count:
       logging.warning("WARNING: NOT USING SUPPRESSIONS!")
 
     # Un-comment to dump Dr.Memory events on error
     #proc += ["-dr_ops", "-dumpcore_mask 0x8bff"]
 
     # Un-comment to debug Dr.Memory
     #proc += ["-dr_ops", "-no_hide -msgbox_mask 15"]
 
     if self._options.use_debug:
       proc += ["-debug"]
 
-    proc += ["-logdir", self.log_dir]
+    proc += ["-logdir", _Cygpath(self.log_dir)]
     proc += ["-batch", "-quiet", "-no_results_to_stderr"]
 
     proc += ["-callstack_max_frames", "40"]
 
     # make callstacks easier to read
     proc += ["-callstack_srcfile_prefix",
              "build\\src,chromium\\src,crt_build\\self_x86"]
     proc += ["-callstack_modname_hide",
              "*.exe,chrome.dll"]
 
     boring_callers = common.BoringCallers(mangled=False, use_re_wildcards=False)
     # TODO(timurrrr): In fact, we want "starting from .." instead of "below .."
     proc += ["-callstack_truncate_below", ",".join(boring_callers)]
 
     if not self.handle_uninits_and_leaks:
       proc += ["-no_check_uninitialized", "-no_count_leaks"]
 
     proc += self._tool_flags
 
     # Dr.Memory requires -- to separate tool flags from the executable name.
     proc += ["--"]
 
     if self._options.indirect:
       self.CreateBrowserWrapper(" ".join(proc))
       proc = []
 
     # Note that self._args begins with the name of the exe to be run.
+    self._args[0] = _Cygpath(self._args[0])
     proc += self._args
     return proc
 
   def CreateBrowserWrapper(self, command):
     os.putenv("BROWSER_WRAPPER", command)
 
   def Analyze(self, check_sanity=False):
     # Glob all the results files in the "testing.tmp" directory
     filenames = glob.glob(self.log_dir + "/*/results.txt")
 
@@ skipping 247 matching lines @@
       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)