Support total and per-second task/threadtime timeline metrics

tools/perf/metrics/timeline_unittest.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import unittest
 
 from telemetry.timeline import model as model_module
 from telemetry.unittest_util import test_page_test_results
 from telemetry.web_perf import timeline_interaction_record as tir_module
 
@@ skipping 91 matching lines @@
     renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
     renderer_main.name = 'CrRendererMain'
 
     metric = timeline.ThreadTimesTimelineMetric()
     metric.details_to_report = timeline.ReportMainThreadOnly
     results = self.GetResults(metric, model, renderer_main.parent,
                               [_GetInteractionRecord(1,2)])
 
     # Test that all result thread categories exist
     for name in timeline.TimelineThreadCategories.values():
-      results.GetPageSpecificValueNamed(timeline.ThreadCpuTimeResultName(name))
+      results.GetPageSpecificValueNamed(
+          timeline.ThreadCpuTimeResultName(name, 'frame'))
 
   def testBasic(self):
     model = model_module.TimelineModel()
     renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
     renderer_main.name = 'CrRendererMain'
 
-    # Create two frame swaps (Results times should be divided by two)
+    # Create two frame swaps (Results times should be divided by two) for
+    # an interaction that lasts 20 milliseconds.
     cc_main = model.GetOrCreateProcess(1).GetOrCreateThread(3)
     cc_main.name = 'Compositor'
     cc_main.BeginSlice('cc_cat', timeline.FrameTraceName, 10, 10)
     cc_main.EndSlice(11, 11)
     cc_main.BeginSlice('cc_cat', timeline.FrameTraceName, 12, 12)
     cc_main.EndSlice(13, 13)
 
     # [      X       ]   [ Z ]
     #      [  Y  ]
     renderer_main.BeginSlice('cat1', 'X', 10, 0)
     renderer_main.BeginSlice('cat2', 'Y', 15, 5)
     renderer_main.EndSlice(16, 5.5)
     renderer_main.EndSlice(30, 19.5)
     renderer_main.BeginSlice('cat1', 'Z', 31, 20)
     renderer_main.BeginSlice('cat1', 'Z', 33, 21)
     model.FinalizeImport()
 
     # Exclude 'Z' using an action-range.
     metric = timeline.ThreadTimesTimelineMetric()
     metric.details_to_report = timeline.ReportMainThreadOnly
     results = self.GetResults(metric, model, renderer_main.parent,
                               [_GetInteractionRecord(10, 30)])
 
     # Test for the results we expect.
     main_thread = "renderer_main"
     cc_thread = 'renderer_compositor'
     assert_results = [
-      (timeline.ThreadCpuTimeResultName(main_thread), 'ms', 9.75),
-      (timeline.ThreadTasksResultName(main_thread), 'tasks', 0.5),
       (timeline.ThreadMeanFrameTimeResultName(cc_thread), 'ms', 10.0),
-      (timeline.ThreadDetailResultName(main_thread,'cat1'), 'ms', 9.5),
-      (timeline.ThreadDetailResultName(main_thread,'cat2'), 'ms', 0.5),
-      (timeline.ThreadDetailResultName(main_thread,'idle'), 'ms', 0)
+      (timeline.ThreadTasksResultName(main_thread, 'frame'), 'tasks', 0.5),
+      (timeline.ThreadTasksResultName(main_thread, 'second'), 'tasks', 50.0),
+      (timeline.ThreadTasksResultName(cc_thread, 'frame'), 'tasks', 1.0),
+      (timeline.ThreadTasksResultName(cc_thread, 'second'), 'tasks', 100.0),
+      (timeline.ThreadCpuTimeResultName(main_thread, 'frame'), 'ms', 9.75),
+      (timeline.ThreadCpuTimeResultName(main_thread, 'second'), '%', 97.5),
+      (timeline.ThreadCpuTimeResultName(cc_thread, 'frame'), 'ms', 1.0),
+      (timeline.ThreadCpuTimeResultName(cc_thread, 'second'), '%', 10.0),
+      (timeline.ThreadDetailResultName(main_thread, 'frame', 'cat1'),
+       'ms', 9.5),
+      (timeline.ThreadDetailResultName(main_thread, 'second', 'cat1'),
+       '%', 95.0),
+      (timeline.ThreadDetailResultName(main_thread, 'frame', 'cat2'),
+       'ms', 0.5),
+      (timeline.ThreadDetailResultName(main_thread, 'second', 'cat2'),
+       '%', 5.0),
+      (timeline.ThreadDetailResultName(main_thread, 'frame', 'idle'), 'ms', 0),
+      (timeline.ThreadDetailResultName(main_thread, 'second', 'idle'), '%', 0)
     ]
     for name, unit, value in assert_results:
       results.AssertHasPageSpecificScalarValue(name, unit, value)
 
   def testOverheadIsRemoved(self):
     model = model_module.TimelineModel()
     renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
     renderer_main.name = 'CrRendererMain'
 
     # Create one frame swap.
@@ skipping 12 matching lines @@
     renderer_main.EndSlice(30, 10)
     model.FinalizeImport()
 
     # Include everything in an action-range.
     metric = timeline.ThreadTimesTimelineMetric()
     metric.details_to_report = timeline.ReportMainThreadOnly
     results = self.GetResults(metric, model, renderer_main.parent,
                               [_GetInteractionRecord(10, 30)])
 
     # Test a couple specific results.
-    assert_results = {
-      timeline.ThreadCpuTimeResultName('renderer_main') : 9.0,
-    }
-    for name, value in assert_results.iteritems():
-      results.AssertHasPageSpecificScalarValue(name, 'ms', value)
+    assert_results = [
+      (timeline.ThreadCpuTimeResultName('renderer_main', 'frame') , 'ms', 9.0),
+      (timeline.ThreadCpuTimeResultName('renderer_main', 'second') , '%', 45.0),
+    ]
+    for name, unit, value in assert_results:
+      results.AssertHasPageSpecificScalarValue(name, unit, value)