Fix tools/valgrind/chrome_tests.sh to always use --log-file option...

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.
 
 # purify_test.py
 
 '''Runs an exe through Valgrind and puts the intermediate files in a
 directory.
 '''
@@ skipping 118 matching lines @@
     common.RunSubprocess(proc, self._timeout)
 
     # Always return true, even if running the subprocess failed. We depend on
     # Analyze to determine if the run was valid. (This behaviour copied from
     # the purify_test.py script.)
     return True
 
   def Analyze(self):
     # Glob all the files in the "valgrind.tmp" directory
     filenames = glob.glob(self.TMP_DIR + "/valgrind.*")
+    # TODO(dkegel): use new xml suppressions feature when it lands
+    if self._generate_suppressions:
+      # Just concatenate all the output files.  Lame...
+      for filename in filenames:
+        print "## %s" % filename
+        f = file(filename)
+        while True:
+          line = f.readline()
+          if len(line) == 0:
+            break
+          print line, # comma means don't add newline
+        f.close()
+      return 0
     analyzer = valgrind_analyze.ValgrindAnalyze(self._source_dir, filenames, self._options.show_all_leaks)
     return analyzer.Report()
 
   def Cleanup(self):
     # Right now, we can cleanup by deleting our temporary directory. Other
     # cleanup is still a TODO?
     shutil.rmtree(self.TMP_DIR)
     return True
 
   def RunTestsAndAnalyze(self):
     self.PrepareForTest()
     self.Execute()
-    if self._generate_suppressions:
-      logging.info("Skipping analysis to let you look at the raw output...")
-      return 0
 
     retcode = self.Analyze()
     if retcode:
       logging.error("Analyze failed.")
       return retcode
     logging.info("Execution and analysis completed successfully.")
     return 0
 
   def Main(self):
     '''Call this to run through the whole process: Setup, Execute, Analyze'''
@@ skipping 53 matching lines @@
 
       suppression_count = 0
       for suppression_file in self._suppressions:
         if os.path.exists(suppression_file):
           suppression_count += 1
           proc += ["--suppressions=%s" % suppression_file]
 
       if not suppression_count:
         logging.warning("WARNING: NOT USING SUPPRESSIONS!")
 
-      if not self._generate_suppressions:
-        # We don't currently collect suppressions from individual log files,
-        # so let it all go to stdout.  This leads to occasional
-        # corruption; see above TODO.
-        proc += ["--log-file=" + self.TMP_DIR + "/valgrind.%p"]
+      proc += ["--log-file=" + self.TMP_DIR + "/valgrind.%p"]
+
     # The Valgrind command is constructed.
 
     if self._options.indirect:
       # 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.TMP_DIR, prefix="browser_wrapper.", text=True)
       f = os.fdopen(fd, "w");
@@ skipping 83 matching lines @@
     valgrind = ValgrindMac()
     retcode = valgrind.Main()
     sys.exit(retcode)
   elif sys.platform == 'linux2': # Linux
     valgrind = ValgrindLinux()
     retcode = valgrind.Main()
     sys.exit(retcode)
   else:
     logging.error("Unknown platform: %s" % sys.platform)
     sys.exit(1)