Remove old count and overview fuzzer elements

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 29 matching lines @@
 )
 
 const (
         // OAUTH2_CALLBACK_PATH is callback endpoint used for the Oauth2 flow.
         OAUTH2_CALLBACK_PATH = "/oauth2callback/"
 )
 
 var (
         // indexTemplate is the main index.html page we serve.
         indexTemplate *template.Template = nil
-        // detailsTemplate is used for /category/foo, which displays the number of
-        // fuzzes by file/function/line
-        overviewTemplate *template.Template = nil
-        // detailsTemplate is used for /details, which displays the information from
-        // overview as well as the stacktraces and fuzzes.
+        // detailsTemplate is used for /category, which displays the count of fuzzes in various files
+        // as well as the stacktraces.
         detailsTemplate *template.Template = nil
 
         storageClient *storage.Client = nil
 
         versionWatcher *fcommon.VersionWatcher = nil
 
         fuzzSyncer *syncer.FuzzSyncer = nil
 )
 
 var (
@@ skipping 26 matching lines @@
 
 func Init() {
         reloadTemplates()
 }
 
 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.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"),
         ))
 }
 
@@ skipping 105 matching lines @@
         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|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))
 }
 
 func indexHandler(w http.ResponseWriter, r *http.Request) {
@@ skipping 17 matching lines @@
                 Category string
         }{
                 Category: mux.Vars(r)["category"],
         }
 
         if err := detailsTemplate.Execute(w, cat); err != nil {
                 glog.Errorf("Failed to expand template: %v", err)
         }
 }
 
-func summaryPageHandler(w http.ResponseWriter, r *http.Request) {
-        if *local {
-                reloadTemplates()
-        }
-        w.Header().Set("Content-Type", "text/html")
-
-        var cat = struct {
-                Category string
-        }{
-                Category: mux.Vars(r)["category"],
-        }
-
-        if err := overviewTemplate.Execute(w, cat); err != nil {
-                glog.Errorf("Failed to expand template: %v", err)
-        }
-}
-
 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()
-        }
+        summary := getSummary()
 
-        if err := json.NewEncoder(w).Encode(overview); err != nil {
+        if err := json.NewEncoder(w).Encode(summary); err != nil {
                 glog.Errorf("Failed to write or encode output: %v", err)
                 return
         }
 }
 
-func getOverview() []countSummary {
-        overviews := make([]countSummary, 0, len(fcommon.FUZZ_CATEGORIES))
+func getSummary() []countSummary {
+        counts := make([]countSummary, 0, len(fcommon.FUZZ_CATEGORIES))
         for _, cat := range fcommon.FUZZ_CATEGORIES {
                 o := countSummary{
                         CategoryDisplay: fcommon.PrettifyCategory(cat),
                         Category:        cat,
                 }
                 c := syncer.FuzzCount{
                         TotalBad:  -1,
                         TotalGrey: -1,
                         ThisBad:   -1,
                         ThisGrey:  -1,
                 }
                 if fuzzSyncer != nil {
                         c = fuzzSyncer.LastCount(cat)
                 }
                 o.TotalBad = c.TotalBad
                 o.ThisBad = c.ThisBad
                 o.TotalGrey = c.TotalGrey
                 o.ThisGrey = c.ThisGrey
-                overviews = append(overviews, o)
+                counts = append(counts, o)
         }
-        return overviews
+        return counts
 }
 
 func detailsJSONHandler(w http.ResponseWriter, r *http.Request) {
         w.Header().Set("Content-Type", "application/json")
 
         category := r.FormValue("category")
         name := r.FormValue("name")
         // The file names have "/" in them and the functions can have "(*&" in them.
         // We base64 encode them to prevent problems.
         file, err := decodeBase64(r.FormValue("file"))
@@ skipping 125 matching lines @@
                         }
                 }
         }
 
         if err := json.NewEncoder(w).Encode(s); err != nil {
                 glog.Errorf("Failed to write or encode output: %s", err)
                 return
         }
 }
 
-func fuzzCountHandler(w http.ResponseWriter, r *http.Request) {
-        c := syncer.FuzzCount{
-                TotalBad:  -1,
-                TotalGrey: -1,
-                ThisBad:   -1,
-                ThisGrey:  -1,
-        }
-        if fuzzSyncer != nil {
-                c = fuzzSyncer.LastCount(r.FormValue("category"))
-        }
-        if err := json.NewEncoder(w).Encode(c); err != nil {
-                glog.Errorf("Failed to write or encode output: %s", err)
-                return
-        }
-}
-
 type newBug struct {
         Category       string
         PrettyCategory string
         Name           string
         Revision       string
 }
 
 var newBugTemplate = template.Must(template.New("new_bug").Parse(`# Your bug description here about fuzz found in {{.PrettyCategory}}
 
 # tracking metadata below:
@@ skipping 19 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)
 }