Remove old count and overview fuzzer elements

fuzzer/go/frontend/data/report.go

 package data
 
 import (
         "bytes"
         "encoding/gob"
         "fmt"
         "sort"
         "sync"
 
         "github.com/skia-dev/glog"
@@ skipping 58 matching lines @@
                 caches: map[string]*fuzzReportCache{},
         }
 }
 
 // A fuzzReportCache holds three FuzzReportTrees - one for the raw data, a sorted version with
 // all of the reports and an empty tree that holds no reports.  These are used to procure data
 // for the frontend.
 type fuzzReportCache struct {
         // All the data goes in here, in no particular order
         rawData FuzzReportTree
-        // Generated, sorted caches
-        FullReport    FuzzReportTree
-        SummaryReport FuzzReportTree
+        // Generated, sorted cache
+        FullReport FuzzReportTree
 
-        // If data is in rawData, but not in SummaryReport or FullReport, the trees should be
+        // If data is in rawData, but not in FullReport, the trees should be
         // rebuilt
         isDirty bool
 }
 
 // currentData is the object that holds the cache of fuzz results.  It is used by the frontend.
 var currentData = newBuilder()
 
 // stagingData is the object that processes can write to to queue up new data
 // without disturbing the data shown to users.
 var stagingData = newBuilder()
 
-func FindFuzzSummary(category string) FuzzReportTree {
-        cache, found := currentData.caches[category]
-        if !found {
-                return FuzzReportTree{}
-        }
-        return cache.SummaryReport
-}
-
 // FindFuzzDetails returns the detailed fuzz reports for a file name, function name, and line number.
 // If functionName is "" or lineNumber is -1, all reports are shown.
 func FindFuzzDetails(category, fileName, functionName string, lineNumber int) (FuzzReportTree, error) {
         cache, found := currentData.caches[category]
         if found {
                 if fileName == "" {
                         return cache.FullReport, nil
                 }
                 for _, file := range cache.FullReport {
                         if file.FileName == fileName {
@@ skipping 25 matching lines @@
 
 // filterByLineNumber removes all FuzzReportLineNumber except that which matches lineNumber
 func (function *FunctionFuzzReport) filterByLineNumber(lineNumber int) {
         for _, line := range function.LineNumbers {
                 if lineNumber == line.LineNumber {
                         function.LineNumbers = []LineFuzzReport{line}
                 }
         }
 }
 
-func CategoryOverview(category string) FuzzReportTree {
-        overview, found := currentData.caches[category]
-        if found {
-                return overview.SummaryReport
-        }
-        return FuzzReportTree{}
-}
-
 // FindFuzzDetailForFuzz returns a tree containing the single
 // report with the given name, or an error, it it doesn't exist.
 func FindFuzzDetailForFuzz(category, name string) (FuzzReportTree, error) {
         if cache, found := currentData.caches[category]; found {
                 for _, file := range cache.FullReport {
                         if file.filterByFuzzName(name) {
                                 return FuzzReportTree{file}, nil
                         }
                 }
         }
@@ skipping 192 matching lines @@
                 return FuzzReportTree{}
         }
         if cache.isDirty {
                 r.mutex.Lock()
                 defer r.mutex.Unlock()
                 cache.rebuildSortedReports()
         }
         return cache.FullReport
 }
 
-// getSummarySortedByTotal gets the summary FuzzReport for a fuzz category
-// sorted by total number of fuzzes.
-func (r *treeReportBuilder) getSummarySortedByTotal(category string) FuzzReportTree {
-        cache, found := r.caches[category]
-        if !found {
-                glog.Warningf("Could not find report tree for category %s", category)
-                return FuzzReportTree{}
-        }
-        if cache.isDirty {
-                r.mutex.Lock()
-                defer r.mutex.Unlock()
-                cache.rebuildSortedReports()
-        }
-        return cache.SummaryReport
-}
-
 // rebuildSortedReports creates the sorted reports for a given cache.
 func (c *fuzzReportCache) rebuildSortedReports() {
         c.FullReport = c.getClonedSortedReport(true)
-        c.SummaryReport = c.getClonedSortedReport(false)
         c.isDirty = false
 }
 
 // getClonedSortedReport makes a newly allocated FuzzReport after running the passed in function
 // on all FuzzReportLineNumber objects in the report.
 func (c *fuzzReportCache) getClonedSortedReport(keepDetails bool) FuzzReportTree {
         report := cloneReport(c.rawData)
         sort.Sort(filesTotalSort(report))
         for i := range report {
                 file := &report[i]
@@ skipping 92 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
 }