Don't double-JSON-escape crash stacks in asan symbolizer.

tools/valgrind/asan/asan_symbolize.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.
 
 from third_party import asan_symbolize
 
 import argparse
 import base64
@@ skipping 145 matching lines @@
   # is located in the product dir.
   outermost_bundle = bundle_positions[0]
   product_dir = path_parts[:outermost_bundle]
   # In case 2 this is the same as |outermost_bundle|.
   innermost_bundle = bundle_positions[-1]
   dsym_path = product_dir + [path_parts[innermost_bundle]]
   result = '%s.dSYM' % os.path.join(*dsym_path)
   return [result]
 
 
-# We want our output to match base::EscapeJSONString(), which produces
-# doubly-escaped strings. The first escaping pass is handled by this class. The
-# second pass happens when JSON data is dumped to file.
-class StringEncoder(json.JSONEncoder):
-  def __init__(self):
-    json.JSONEncoder.__init__(self)
-
-  def encode(self, s):
-    assert(isinstance(s, basestring))
-    # Don't die on invalid utf-8 sequences.
-    s = s.decode('utf-8', 'replace')
-    encoded = json.JSONEncoder.encode(self, s)
-    assert(len(encoded) >= 2)
-    assert(encoded[0] == '"')
-    assert(encoded[-1] == '"')
-    encoded = encoded[1:-1]
-    # Special case from base::EscapeJSONString().
-    encoded = encoded.replace('<', '\u003C')
-    return encoded
-
-
 class JSONTestRunSymbolizer(object):
   def __init__(self, symbolization_loop):
     self.symbolization_loop = symbolization_loop
 
   def symbolize_snippet(self, snippet):
     symbolized_lines = []
     for line in snippet.split('\n'):
       symbolized_lines += self.symbolization_loop.process_line(line)
     return '\n'.join(symbolized_lines)
 
   def symbolize(self, test_run):
     original_snippet = base64.b64decode(test_run['output_snippet_base64'])
     symbolized_snippet = self.symbolize_snippet(original_snippet)
     if symbolized_snippet == original_snippet:
       # No sanitizer reports in snippet.
       return
 
     test_run['original_output_snippet'] = test_run['output_snippet']
     test_run['original_output_snippet_base64'] = \
         test_run['output_snippet_base64']
 
-    escaped_snippet = StringEncoder().encode(symbolized_snippet)
-    test_run['output_snippet'] = escaped_snippet
+    test_run['output_snippet'] = symbolized_snippet
     test_run['output_snippet_base64'] = \
         base64.b64encode(symbolized_snippet)
     test_run['snippet_processed_by'] = 'asan_symbolize.py'
-    # Originally, "lossless" refers to "no Unicode data lost while encoding the
-    # string". However, since we're applying another kind of transformation
-    # (symbolization), it doesn't seem right to consider the snippet lossless.
-    test_run['losless_snippet'] = False
 
 
 def symbolize_snippets_in_json(filename, symbolization_loop):
   with open(filename, 'r') as f:
     json_data = json.load(f)
 
   test_run_symbolizer = JSONTestRunSymbolizer(symbolization_loop)
   for iteration_data in json_data['per_iteration_data']:
     for test_name, test_runs in iteration_data.iteritems():
       for test_run in test_runs:
@@ skipping 35 matching lines @@
 
   if args.test_summary_json_file:
     symbolize_snippets_in_json(args.test_summary_json_file, loop)
   else:
     # Process stdin.
     asan_symbolize.logfile = sys.stdin
     loop.process_logfile()
 
 if __name__ == '__main__':
   main()