Add UI to filter fuzzes based on tags.

fuzzer/go/fuzzer-fe/main.go

 package main
 
 /*
 Runs the frontend portion of the fuzzer.  This primarily is the webserver (see DESIGN.md)
 */
 
 import (
         "bytes"
         "encoding/base64"
         "encoding/json"
@@ skipping 84 matching lines @@
 
 func reloadTemplates() {
         indexTemplate = template.Must(template.ParseFiles(
                 filepath.Join(*resourcesDir, "templates/index.html"),
                 filepath.Join(*resourcesDir, "templates/header.html"),
         ))
         overviewTemplate = template.Must(template.ParseFiles(
                 filepath.Join(*resourcesDir, "templates/overview.html"),
                 filepath.Join(*resourcesDir, "templates/header.html"),
         ))
-        detailsTemplate = template.Must(template.ParseFiles(
+        detailsTemplate = template.New("details.html")
+        // Allows this template to have Polymer binding in it and go template markup.  The go templates
+        // have been changed to be {%.Thing%} instead of {{.Thing}}
+        detailsTemplate.Delims("{%", "%}")
+        detailsTemplate = template.Must(detailsTemplate.ParseFiles(
                 filepath.Join(*resourcesDir, "templates/details.html"),
                 filepath.Join(*resourcesDir, "templates/header.html"),
         ))
 }
 
 func main() {
         defer common.LogPanic()
         // Calls flag.Parse()
         common.InitWithMetrics("fuzzer", graphiteServer)
 
@@ skipping 87 matching lines @@
         serverURL := "https://" + *host
         if *local {
                 serverURL = "http://" + *host + *port
         }
 
         r := mux.NewRouter()
         r.PathPrefix("/res/").HandlerFunc(util.MakeResourceHandler(*resourcesDir))
 
         r.HandleFunc(OAUTH2_CALLBACK_PATH, login.OAuth2CallbackHandler)
         r.HandleFunc("/", indexHandler)
-        r.HandleFunc("/category/{category:[a-z_]+}", summaryPageHandler)
+        r.HandleFunc("/category/{category:[a-z_]+}", detailsPageHandler)
         r.HandleFunc("/category/{category:[a-z_]+}/name/{name}", detailsPageHandler)
         r.HandleFunc("/category/{category:[a-z_]+}/file/{file}", detailsPageHandler)
         r.HandleFunc("/category/{category:[a-z_]+}/file/{file}/func/{function}", detailsPageHandler)
         r.HandleFunc(`/category/{category:[a-z_]+}/file/{file}/func/{function}/line/{line}`, detailsPageHandler)
         r.HandleFunc("/loginstatus/", login.StatusHandler)
         r.HandleFunc("/logout/", login.LogoutHandler)
         r.HandleFunc("/json/version", skiaversion.JsonHandler)
         r.HandleFunc("/json/fuzz-summary", summaryJSONHandler)
         r.HandleFunc("/json/details", detailsJSONHandler)
         r.HandleFunc("/json/status", statusJSONHandler)
         r.HandleFunc(`/fuzz/{category:[a-z_]+}/{name:[0-9a-f]+}`, fuzzHandler)
-        r.HandleFunc(`/metadata/{category:[a-z_]+}/{name:[0-9a-f]+_(debug|release)\.(err|dump)}`, metadataHandler)
+        r.HandleFunc(`/metadata/{category:[a-z_]+}/{name:[0-9a-f]+_(debug|release)\.(err|dump|asan)}`, metadataHandler)
         r.HandleFunc("/fuzz_count", fuzzCountHandler)
         r.HandleFunc("/newBug", newBugHandler)
 
         rootHandler := login.ForceAuth(util.LoggingGzipRequestResponse(r), OAUTH2_CALLBACK_PATH)
 
         http.Handle("/", rootHandler)
         glog.Infof("Ready to serve on %s", serverURL)
         glog.Fatal(http.ListenAndServe(*port, nil))
 }
 
@@ skipping 35 matching lines @@
                 Category string
         }{
                 Category: mux.Vars(r)["category"],
         }
 
         if err := overviewTemplate.Execute(w, cat); err != nil {
                 glog.Errorf("Failed to expand template: %v", err)
         }
 }
 
-type fuzzOverview struct {
+type countSummary struct {
         Category        string `json:"category"`
         CategoryDisplay string `json:"categoryDisplay"`
         TotalBad        int    `json:"totalBadCount"`
         TotalGrey       int    `json:"totalGreyCount"`
         // "This" means "newly introduced/fixed in this revision"
         ThisBad  int `json:"thisBadCount"`
         ThisGrey int `json:"thisGreyCount"`
 }
 
 func summaryJSONHandler(w http.ResponseWriter, r *http.Request) {
         var overview interface{}
         if cat := r.FormValue("category"); cat != "" {
                 overview = data.CategoryOverview(cat)
         } else {
                 overview = getOverview()
         }
 
         if err := json.NewEncoder(w).Encode(overview); err != nil {
                 glog.Errorf("Failed to write or encode output: %v", err)
                 return
         }
 }
 
-func getOverview() []fuzzOverview {
-        overviews := make([]fuzzOverview, 0, len(fcommon.FUZZ_CATEGORIES))
+func getOverview() []countSummary {
+        overviews := make([]countSummary, 0, len(fcommon.FUZZ_CATEGORIES))
         for _, cat := range fcommon.FUZZ_CATEGORIES {
-                o := fuzzOverview{
+                o := countSummary{
                         CategoryDisplay: fcommon.PrettifyCategory(cat),
                         Category:        cat,
                 }
                 c := syncer.FuzzCount{
                         TotalBad:  -1,
                         TotalGrey: -1,
                         ThisBad:   -1,
                         ThisGrey:  -1,
                 }
                 if fuzzSyncer != nil {
@@ skipping 24 matching lines @@
         if err != nil {
                 util.ReportError(w, r, err, "There was a problem decoding the params.")
                 return
         }
         lineStr, err := decodeBase64(r.FormValue("line"))
         if err != nil {
                 util.ReportError(w, r, err, "There was a problem decoding the params.")
                 return
         }
 
-        var f data.FileFuzzReport
+        var f data.FuzzReportTree
         if name != "" {
                 var err error
                 if f, err = data.FindFuzzDetailForFuzz(category, name); err != nil {
                         util.ReportError(w, r, err, "There was a problem fulfilling the request.")
                 }
         } else {
                 line, err := strconv.ParseInt(lineStr, 10, 32)
                 if err != nil {
                         line = fcommon.UNKNOWN_LINE
                 }
@@ skipping 80 matching lines @@
         w.Header().Set("Content-Type", "application/json")
 
         s := status{
                 Current: commit{
                         Hash:   "loading",
                         Author: "(Loading)",
                 },
                 Pending: nil,
         }
 
-        s.Current.Hash = config.FrontEnd.SkiaVersion.Hash
-        s.Current.Author = config.FrontEnd.SkiaVersion.Author
-        if versionWatcher != nil {
-                if pending := versionWatcher.PendingVersion; pending != nil {
-                        s.Pending = &commit{
-                                Hash:   pending.Hash,
-                                Author: pending.Author,
+        if config.FrontEnd.SkiaVersion != nil {
+                s.Current.Hash = config.FrontEnd.SkiaVersion.Hash
+                s.Current.Author = config.FrontEnd.SkiaVersion.Author
+                if versionWatcher != nil {
+                        if pending := versionWatcher.PendingVersion; pending != nil {
+                                s.Pending = &commit{
+                                        Hash:   pending.Hash,
+                                        Author: pending.Author,
+                                }
                         }
                 }
         }
 
         if err := json.NewEncoder(w).Encode(s); err != nil {
                 glog.Errorf("Failed to write or encode output: %s", err)
                 return
         }
 }
 
@@ skipping 45 matching lines @@
         }
         var t bytes.Buffer
         if err := newBugTemplate.Execute(&t, b); err != nil {
                 util.ReportError(w, r, err, fmt.Sprintf("Could not create template with %#v", b))
                 return
         }
         q.Add("comment", t.String())
         // 303 means "make a GET request to this url"
         http.Redirect(w, r, "https://bugs.chromium.org/p/skia/issues/entry?"+q.Encode(), 303)
 }