Add UI to filter fuzzes based on tags.

fuzzer/go/frontend/data/report.go

 package data
 
 import (
         "bytes"
         "encoding/gob"
         "fmt"
         "sort"
         "sync"
 
         "github.com/skia-dev/glog"
@@ skipping 84 matching lines @@
 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) (FileFuzzReport, error) {
-        cache := currentData.caches[category]
-        for _, file := range cache.FullReport {
-                if file.FileName == fileName {
-                        if functionName == "" {
-                                return file, nil
+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 {
+                                if functionName == "" {
+                                        return FuzzReportTree{file}, nil
+                                }
+                                file.filterByFunctionName(functionName)
+                                if lineNumber == common.UNKNOWN_LINE {
+                                        return FuzzReportTree{file}, nil
+                                }
+                                file.Functions[0].filterByLineNumber(lineNumber)
+                                return FuzzReportTree{file}, nil
                         }
-                        file.filterByFunctionName(functionName)
-                        if lineNumber == common.UNKNOWN_LINE {
-                                return file, nil
-                        }
-                        file.Functions[0].filterByLineNumber(lineNumber)
-                        return file, nil
                 }
         }
-        return FileFuzzReport{}, fmt.Errorf("File %q not found", fileName)
+
+        return nil, fmt.Errorf("File %q not found", fileName)
 }
 
 // filterByFunctionName removes all FuzzReportFunction except that which matches functionName
 func (file *FileFuzzReport) filterByFunctionName(functionName string) {
         for _, function := range file.Functions {
                 if functionName == function.FunctionName {
                         file.Functions = []FunctionFuzzReport{function}
                         break
                 }
         }
@@ skipping 11 matching lines @@
 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) (FileFuzzReport, error) {
+func FindFuzzDetailForFuzz(category, name string) (FuzzReportTree, error) {
         if cache, found := currentData.caches[category]; found {
                 for _, file := range cache.FullReport {
                         if file.filterByFuzzName(name) {
-                                return file, nil
+                                return FuzzReportTree{file}, nil
                         }
                 }
         }
-        return FileFuzzReport{}, fmt.Errorf("Fuzz with name %q not found", name)
+        return nil, fmt.Errorf("Fuzz with name %q not found", name)
 }
 
 // filterByFuzzName filters out all functions that do not contain a fuzz with the given
 // name and returns true.  If such a fuzz does not exist, it returns false.
 func (file *FileFuzzReport) filterByFuzzName(name string) bool {
         for _, function := range file.Functions {
                 if function.filterByFuzzName(name) {
                         file.Functions = []FunctionFuzzReport{function}
                         return true
                 }
@@ skipping 313 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
 }