Add AddressSanitizer to fuzzer analysis

fuzzer/go/frontend/data/report.go

 package data
 
 import (
         "bytes"
         "encoding/gob"
         "fmt"
         "sort"
         "sync"
 
         "github.com/skia-dev/glog"
@@ skipping 14 matching lines @@
         LineNumbers  []LineFuzzReport `json:"byLineNumber"`
 }
 
 type LineFuzzReport struct {
         LineNumber int               `json:"lineNumber"`
         Count      int               `json:"count"`
         Details    SortedFuzzReports `json:"reports"`
 }
 
 type FuzzReport struct {
-        DebugStackTrace    StackTrace `json:"debugStackTrace"`
-        ReleaseStackTrace  StackTrace `json:"releaseStackTrace"`
-        HumanReadableFlags []string   `json:"flags"`
+        DebugStackTrace   StackTrace `json:"debugStackTrace"`
+        ReleaseStackTrace StackTrace `json:"releaseStackTrace"`
+        DebugFlags        []string   `json:"debugFlags"`
+        ReleaseFlags      []string   `json:"releaseFlags"`
 
         FuzzName     string `json:"fuzzName"`
         FuzzCategory string `json:"category"`
 }
 
 type SortedFuzzReports []FuzzReport
 
 // ParseReport creates a report given the raw materials passed in.
-func ParseReport(fuzzName, debugDump, debugErr, releaseDump, releaseErr string) FuzzReport {
-        result := ParseFuzzResult(debugDump, debugErr, releaseDump, releaseErr)
+func ParseReport(g GCSPackage) FuzzReport {
+        result := ParseGCSPackage(g)
         return FuzzReport{
-                DebugStackTrace:    result.DebugStackTrace,
-                ReleaseStackTrace:  result.ReleaseStackTrace,
-                HumanReadableFlags: result.Flags.ToHumanReadableFlags(),
-                FuzzName:           fuzzName,
-                FuzzCategory:       "", // Will be filled in later, when added to the tree
+                DebugStackTrace:   result.Debug.StackTrace,
+                ReleaseStackTrace: result.Release.StackTrace,
+                DebugFlags:        result.Debug.Flags.ToHumanReadableFlags(),
+                ReleaseFlags:      result.Release.Flags.ToHumanReadableFlags(),
+                FuzzName:          g.Name,
+                FuzzCategory:      g.FuzzCategory,
         }
 }
 
 // treeReportBuilder is an in-memory structure that allows easy creation of a tree of reports
 // for use on the frontend. It has a fuzzReportCache for every fuzz type (e.g. skpicture, skcodec, etc)
 type treeReportBuilder struct {
         caches map[string]*fuzzReportCache
         mutex  sync.Mutex
 }
 
@@ skipping 418 matching lines @@
 }
 
 // containsName returns the FuzzReport and true if a fuzz with the given name is in the list.
 func (p SortedFuzzReports) containsName(fuzzName string) (FuzzReport, bool) {
         i := sort.Search(len(p), func(i int) bool { return p[i].FuzzName >= fuzzName })
         if i < len(p) && p[i].FuzzName == fuzzName {
                 return p[i], true
         }
         return FuzzReport{}, false
 }