Cleanup: Remove heapchecker references in tools/valgrind.

tools/valgrind/suppressions.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 # suppressions.py
 
 """Post-process Valgrind suppression matcher.
 
 Suppressions are defined as follows:
@@ skipping 47 matching lines @@
   supp_filename = JOIN(suppressions_root, "memcheck", "suppressions_mac.txt")
   vg_mac = ReadSuppressionsFromFile(supp_filename)
   supp_filename = JOIN(suppressions_root, "tsan", "suppressions_mac.txt")
   tsan_mac = ReadSuppressionsFromFile(supp_filename)
   result['mac_suppressions'] = vg_mac + tsan_mac
 
   supp_filename = JOIN(suppressions_root, "tsan", "suppressions_win32.txt")
   tsan_win = ReadSuppressionsFromFile(supp_filename)
   result['win_suppressions'] = tsan_win
 
-  supp_filename = JOIN(suppressions_root, "..", "heapcheck", "suppressions.txt")
-  result['heapcheck_suppressions'] = ReadSuppressionsFromFile(supp_filename)
-
   supp_filename = JOIN(suppressions_root, "drmemory", "suppressions.txt")
   result['drmem_suppressions'] = ReadSuppressionsFromFile(supp_filename)
   supp_filename = JOIN(suppressions_root, "drmemory", "suppressions_full.txt")
   result['drmem_full_suppressions'] = ReadSuppressionsFromFile(supp_filename)
 
   return result
 
 
 def GlobToRegex(glob_pattern, ignore_case=False):
   """Translate glob wildcards (*?) into regex syntax.  Escape the rest."""
@@ skipping 62 matching lines @@
     if not self.stack:
       return False
     lines = [f.strip() for f in suppression_from_report]
     return self.regex.match('\n'.join(lines) + '\n') is not None
 
 
 def FilenameToTool(filename):
   """Return the name of the tool that a file is related to, or None.
 
   Example mappings:
-    tools/heapcheck/suppressions.txt -> heapcheck
     tools/valgrind/tsan/suppressions.txt -> tsan
     tools/valgrind/drmemory/suppressions.txt -> drmemory
     tools/valgrind/drmemory/suppressions_full.txt -> drmemory
     tools/valgrind/memcheck/suppressions.txt -> memcheck
     tools/valgrind/memcheck/suppressions_mac.txt -> memcheck
   """
   filename = os.path.abspath(filename)
   parts = filename.split(os.sep)
   tool = parts[-2]
-  if tool in ('heapcheck', 'drmemory', 'memcheck', 'tsan'):
+  if tool in ('drmemory', 'memcheck', 'tsan'):
     return tool
   return None
 
 
 def ReadSuppressionsFromFile(filename):
   """Read suppressions from the given file and return them as a list"""
   tool_to_parser = {
     "drmemory":  ReadDrMemorySuppressions,
     "memcheck":  ReadValgrindStyleSuppressions,
     "tsan":      ReadValgrindStyleSuppressions,
-    "heapcheck": ReadValgrindStyleSuppressions,
   }
   tool = FilenameToTool(filename)
   assert tool in tool_to_parser, (
       "unknown tool %s for filename %s" % (tool, filename))
   parse_func = tool_to_parser[tool]
 
   # Consider non-existent files to be empty.
   if not os.path.exists(filename):
     return []
 
   input_file = file(filename, 'r')
   try:
     return parse_func(input_file, filename)
   except SuppressionError:
     input_file.close()
     raise
 
 
 class ValgrindStyleSuppression(Suppression):
   """A suppression using the Valgrind syntax.
 
   Most tools, even ones that are not Valgrind-based, use this syntax, ie
-  Heapcheck, TSan, etc.
+  TSan, etc.
 
   Attributes:
     Same as Suppression.
   """
 
   def __init__(self, description, type, stack, defined_at):
-    """Creates a suppression using the Memcheck, TSan, and Heapcheck syntax."""
+    """Creates a suppression using the Memcheck and TSan, syntax."""
     regex = '{\n.*\n%s\n' % type
     for line in stack:
       if line == ELLIPSIS:
         regex += '(.*\n)*'
       else:
         regex += GlobToRegex(line)
         regex += '\n'
     regex += '(.*\n)*'
     regex += '}'
 
@@ skipping 80 matching lines @@
                                    "%s:%d" % (supp_descriptor, nline)))
       cur_descr = ''
       cur_type = ''
       cur_stack = []
       in_suppression = False
     elif not cur_descr:
       cur_descr = line
       continue
     elif not cur_type:
       if (not line.startswith("Memcheck:") and
-          not line.startswith("ThreadSanitizer:") and
-          (line != "Heapcheck:Leak")):
+          not line.startswith("ThreadSanitizer:")):
         raise SuppressionError(
-            'Expected "Memcheck:TYPE", "ThreadSanitizer:TYPE" '
-            'or "Heapcheck:Leak", got "%s"' % line,
+            'Expected "Memcheck:TYPE" or "ThreadSanitizer:TYPE", '
+            'got "%s"' % line,
             "%s:%d" % (supp_descriptor, nline))
       supp_type = line.split(':')[1]
       if not supp_type in ["Addr1", "Addr2", "Addr4", "Addr8",
                            "Cond", "Free", "Jump", "Leak", "Overlap", "Param",
                            "Value1", "Value2", "Value4", "Value8",
                            "Race", "UnlockNonLocked", "InvalidLock",
                            "Unaddressable", "Uninitialized"]:
         raise SuppressionError('Unknown suppression type "%s"' % supp_type,
                                "%s:%d" % (supp_descriptor, nline))
       cur_type = line
@@ skipping 308 matching lines @@
   test_memcheck_stack_4 = """{
     test
     Memcheck:Addr4
     fun:absolutly
     fun:brilliant
     obj:condition
     fun:detection
     fun:expression
   }"""
 
-  test_heapcheck_stack = """{
-    test
-    Heapcheck:Leak
-    fun:absolutly
-    fun:brilliant
-    obj:condition
-    fun:detection
-    fun:expression
-  }"""
-
   test_tsan_stack = """{
     test
     ThreadSanitizer:Race
     fun:absolutly
     fun:brilliant
     obj:condition
     fun:detection
     fun:expression
   }"""
 
@@ skipping 31 matching lines @@
   ]
 
   positive_memcheck_suppressions_4 = [
     "{\nzzz\nMemcheck:Addr4\nfun:absolutly\n}",
     "{\nzzz\nMemcheck:Unaddressable\nfun:absolutly\n}",
     "{\nzzz\nMemcheck:Addr4\nfun:absolutly\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Unaddressable\n...\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Addr4\n...\nfun:detection\n}",
   ]
 
-  positive_heapcheck_suppressions = [
-    "{\nzzz\nHeapcheck:Leak\n...\nobj:condition\n}",
-    "{\nzzz\nHeapcheck:Leak\nfun:absolutly\n}",
-  ]
-
   positive_tsan_suppressions = [
     "{\nzzz\nThreadSanitizer:Race\n...\nobj:condition\n}",
     "{\nzzz\nThreadSanitizer:Race\nfun:absolutly\n}",
   ]
 
   negative_memcheck_suppressions_1 = [
     "{\nzzz\nMemcheck:Leak\nfun:abnormal\n}",
     "{\nzzz\nMemcheck:Leak\nfun:ab*liant\n}",
     "{\nzzz\nMemcheck:Leak\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Leak\nobj:condition\n}",
@@ skipping 23 matching lines @@
     "{\nzzz\nMemcheck:Addr1\nfun:abnormal\n}",
     "{\nzzz\nMemcheck:Addr4\nfun:abnormal\n}",
     "{\nzzz\nMemcheck:Unaddressable\nfun:abnormal\n}",
     "{\nzzz\nMemcheck:Addr1\nfun:absolutly\n}",
     "{\nzzz\nMemcheck:Addr2\nfun:ab*liant\n}",
     "{\nzzz\nMemcheck:Value4\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Leak\nobj:condition\n}",
     "{\nzzz\nMemcheck:Addr8\nfun:brilliant\n}",
   ]
 
-  negative_heapcheck_suppressions = [
-    "{\nzzz\nMemcheck:Leak\nfun:absolutly\n}",
-    "{\nzzz\nHeapcheck:Leak\nfun:brilliant\n}",
-  ]
-
   negative_tsan_suppressions = [
     "{\nzzz\nThreadSanitizer:Leak\nfun:absolutly\n}",
     "{\nzzz\nThreadSanitizer:Race\nfun:brilliant\n}",
   ]
 
   TestStack(test_memcheck_stack_1,
             positive_memcheck_suppressions_1,
             negative_memcheck_suppressions_1)
   TestStack(test_memcheck_stack_2,
             positive_memcheck_suppressions_2,
             negative_memcheck_suppressions_2)
   TestStack(test_memcheck_stack_3,
             positive_memcheck_suppressions_3,
             negative_memcheck_suppressions_3)
   TestStack(test_memcheck_stack_4,
             positive_memcheck_suppressions_4,
             negative_memcheck_suppressions_4)
-  TestStack(test_heapcheck_stack, positive_heapcheck_suppressions,
-            negative_heapcheck_suppressions)
   TestStack(test_tsan_stack, positive_tsan_suppressions,
             negative_tsan_suppressions)
 
   # TODO(timurrrr): add TestFailPresubmit tests.
 
   ### DrMemory self tests.
 
   # http://crbug.com/96010 suppression.
   stack_96010 = """{
     UNADDRESSABLE ACCESS
@@ skipping 172 matching lines @@
   bad_stack_frame = """
     UNADDRESSABLE ACCESS
     name=http://crbug.com/1234
     fun:memcheck_style_frame
   """
   TestFailPresubmit(bad_stack_frame, 'Unexpected stack frame pattern',
                     suppression_parser=ReadDrMemorySuppressions)
 
   # Test FilenameToTool.
   filenames_to_tools = {
-    "tools/heapcheck/suppressions.txt": "heapcheck",
     "tools/valgrind/tsan/suppressions.txt": "tsan",
     "tools/valgrind/drmemory/suppressions.txt": "drmemory",
     "tools/valgrind/drmemory/suppressions_full.txt": "drmemory",
     "tools/valgrind/memcheck/suppressions.txt": "memcheck",
     "tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
     "asdf/tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
     "foo/bar/baz/tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
     "foo/bar/baz/tools/valgrind/suppressions.txt": None,
     "tools/valgrind/suppressions.txt": None,
   }
@@ skipping 35 matching lines @@
               "instruction=test 0x08(%eax) $0x01\n"
               "ntdll.dll!*\n"
               "*!foo\n")
   assert str(supp) == supp_str, (
       "str(supp) != supp_str:\nleft: %s\nright: %s" % (str(supp), supp_str))
 
 
 if __name__ == '__main__':
   SelfTest()
   print 'PASS'