Ignore traces

golden/go/analysis/triage.go

 package analysis
 
 import (
         "sort"
 
         "github.com/skia-dev/glog"
 
         "skia.googlesource.com/buildbot.git/golden/go/types"
         ptypes "skia.googlesource.com/buildbot.git/perf/go/types"
 )
@@ skipping 64 matching lines @@
 
 // GUITestDetailSortable is a wrapper to sort a slice of GUITestDetail.
 type GUITestDetailSortable []*GUITestDetail
 
 func (g GUITestDetailSortable) Len() int           { return len(g) }
 func (g GUITestDetailSortable) Swap(i, j int)      { g[i], g[j] = g[j], g[i] }
 func (g GUITestDetailSortable) Less(i, j int) bool { return g[i].Name < g[j].Name }
 
 // getTestDetails processes a tile and calculates the diff metrics for all
 // untriaged digests.
-func (a *Analyzer) getTestDetails(labeledTile *LabeledTile) *GUITestDetails {
-        glog.Infof("Latest commit: %v", labeledTile.Commits[len(labeledTile.Commits)-1])
+func (a *Analyzer) getTestDetails(state *AnalyzeState) *GUITestDetails {
+        glog.Infof("Latest commit: %v", state.Tile.Commits[len(state.Tile.Commits)-1])
         glog.Infoln("Starting to extract test details.")
-        nTests := len(labeledTile.Traces)
+        nTests := len(state.Tile.Traces)
         resultCh := make(chan *GUITestDetail, nTests)
 
-        for testName, testTraces := range labeledTile.Traces {
+        for testName, testTraces := range state.Tile.Traces {
                 go a.processOneTestDetail(testName, testTraces, resultCh)
         }
 
         // Wait for the results to finish.
         result := make([]*GUITestDetail, 0, nTests)
         for i := 0; i < nTests; i++ {
                 result = append(result, <-resultCh)
                 glog.Infof("Processed %d/%d tests. (%f%%)", len(result), nTests, float64(len(result))/float64(nTests)*100.0)
         }
 
         // Sort the resulting tests by name.
         sort.Sort(GUITestDetailSortable(result))
 
         // Build the test lookup map.
         testsMap := make(map[string]int, nTests)
         for idx, t := range result {
                 testsMap[t.Name] = idx
         }
 
         glog.Infoln("Done extracting test details.")
 
         return &GUITestDetails{
-                Commits:         labeledTile.Commits,
-                CommitsByDigest: labeledTile.CommitsByDigest,
-                AllParams:       a.currentIndex.getAllParams(nil),
+                Commits:         state.Tile.Commits,
+                CommitsByDigest: state.Tile.CommitsByDigest,
+                AllParams:       state.Index.getAllParams(nil),
                 Tests:           result,
                 testsMap:        testsMap,
         }
 }
 
-func (a *Analyzer) updateTestDetails(labeledTestDigests map[string]types.TestClassification) {
-        glog.Infof("Latest commit: %v", a.currentTestDetails.Commits[len(a.currentTestDetails.Commits)-1])
+func (a *Analyzer) updateTestDetails(labeledTestDigests map[string]types.TestClassification, state *AnalyzeState) {
+        glog.Infof("Latest commit: %v", state.TestDetails.Commits[len(state.TestDetails.Commits)-1])
         glog.Infoln("Starting to update test details.")
         nTests := len(labeledTestDigests)
         resultCh := make(chan *GUITestDetail, nTests)
 
         for testName := range labeledTestDigests {
-                go a.processOneTestDetail(testName, a.currentTile.Traces[testName], resultCh)
+                go a.processOneTestDetail(testName, state.Tile.Traces[testName], resultCh)
         }
 
         // Wait for the results to finish.
-        curr := a.currentTestDetails.Tests
+        curr := state.TestDetails.Tests
         for i := 0; i < nTests; i++ {
                 result := <-resultCh
 
                 // find the result in the current tile and replace it.
                 idx := sort.Search(len(curr), func(j int) bool { return curr[j].Name >= result.Name })
                 // We found the entry.
                 if (idx < len(curr)) && (curr[idx].Name == result.Name) {
                         curr[idx] = result
-                } else {
-                        glog.Errorf("Unable to find test '%s'", result.Name)
                 }
         }
 
         glog.Infoln("Done updating test details.")
 }
 
 func (a *Analyzer) processOneTestDetail(testName string, testTraces []*LabeledTrace, resultCh chan<- *GUITestDetail) {
         untriagedDigests := map[string]*GUIUntriagedDigest{}
         positiveDigests := map[string]*DigestInfo{}
         negativeDigests := map[string]*DigestInfo{}
@@ skipping 156 matching lines @@
                 result = append(result, &GUIDiffMetric{
                         NumDiffPixels:    dm.NumDiffPixels,
                         PixelDiffPercent: dm.PixelDiffPercent,
                         MaxRGBADiffs:     dm.MaxRGBADiffs,
                         DiffImgUrl:       a.pathToURLConverter(dm.PixelDiffFilePath),
                         PosDigest:        posDigest,
                 })
         }
         return result
 }