telemetry: Replace mostly_smooth by percentage_smooth.

R=tonyg@chromium.org,qyearsley@chromium.org,nednguyen@chromium.org
BUG=422093

Review URL: https://codereview.chromium.org/645753002

Cr-Commit-Position: refs/heads/master@{#299189}

tools/perf/measurements/repaint_unittest.py

@@ -50,9 +50,10 @@ class RepaintUnitTest(page_test_test_case.PageTestTestCase):
     self.assertEquals(len(jank), 1)
     self.assertGreater(jank[0].GetRepresentativeNumber(), 0)
 
-    mostly_smooth = results.FindAllPageSpecificValuesNamed('mostly_smooth')
-    self.assertEquals(len(mostly_smooth), 1)
-    self.assertGreaterEqual(mostly_smooth[0].GetRepresentativeNumber(), 0)
+    percentage_smooth = results.FindAllPageSpecificValuesNamed(
+        'percentage_smooth')
+    self.assertEquals(len(percentage_smooth), 1)
+    self.assertGreaterEqual(percentage_smooth[0].GetRepresentativeNumber(), 0)
 
   @test.Disabled('android')
   def testCleanUpTrace(self):

tools/perf/measurements/smoothness_unittest.py

@@ -116,9 +116,10 @@ class SmoothnessUnitTest(page_test_test_case.PageTestTestCase):
     self.assertEquals(len(jank), 1)
     self.assertGreater(jank[0].GetRepresentativeNumber(), 0)
 
-    mostly_smooth = results.FindAllPageSpecificValuesNamed('mostly_smooth')
-    self.assertEquals(len(mostly_smooth), 1)
-    self.assertGreaterEqual(mostly_smooth[0].GetRepresentativeNumber(), 0)
+    percentage_smooth = results.FindAllPageSpecificValuesNamed(
+        'percentage_smooth')
+    self.assertEquals(len(percentage_smooth), 1)
+    self.assertGreaterEqual(percentage_smooth[0].GetRepresentativeNumber(), 0)
 
     mean_input_event_latency = results.FindAllPageSpecificValuesNamed(
         'mean_input_event_latency')
@@ -136,9 +137,10 @@ class SmoothnessUnitTest(page_test_test_case.PageTestTestCase):
     results = self.RunMeasurement(measurement, ps, options=self._options)
     self.assertEquals(0, len(results.failures))
 
-    mostly_smooth = results.FindAllPageSpecificValuesNamed('mostly_smooth')
-    self.assertEquals(len(mostly_smooth), 1)
-    self.assertGreaterEqual(mostly_smooth[0].GetRepresentativeNumber(), 0)
+    percentage_smooth = results.FindAllPageSpecificValuesNamed(
+        'percentage_smooth')
+    self.assertEquals(len(percentage_smooth), 1)
+    self.assertGreaterEqual(percentage_smooth[0].GetRepresentativeNumber(), 0)
 
   def testCleanUpTrace(self):
     self.TestTracingCleanedUp(smoothness.Smoothness, self._options)

tools/telemetry/telemetry/web_perf/metrics/smoothness.py

@@ -30,7 +30,7 @@ class SmoothnessMetric(timeline_based_metric.TimelineBasedMetric):
 
     frame_times: A list of raw frame times
     mean_frame_time: The arithmetic mean of frame times
-    mostly_smooth: Whether we hit 60 fps for 95% of all frames
+    percentage_smooth: Percentage of frames that were hitting 60 FPS.
     jank: The absolute discrepancy of frame timestamps
     mean_pixels_approximated: The mean percentage of pixels approximated
     queueing_durations: The queueing delay between compositor & main threads
@@ -146,19 +146,20 @@ class SmoothnessMetric(timeline_based_metric.TimelineBasedMetric):
   def _ComputeFrameTimeMetric(self, page, stats):
     """Returns Values for the frame time metrics.
 
-    This includes the raw and mean frame times, as well as the mostly_smooth
-    metric which tracks whether we hit 60 fps for 95% of the frames.
+    This includes the raw and mean frame times, as well as the percentage of
+    frames that were hitting 60 fps.
     """
     frame_times = None
     mean_frame_time = None
-    mostly_smooth = None
+    percentage_smooth = None
     none_value_reason = None
     if self._HasEnoughFrames(stats.frame_timestamps):
       frame_times = FlattenList(stats.frame_times)
       mean_frame_time = round(statistics.ArithmeticMean(frame_times), 3)
-      # We use 19ms as a somewhat looser threshold, instead of 1000.0/60.0.
-      percentile_95 = statistics.Percentile(frame_times, 95.0)
-      mostly_smooth = 1.0 if percentile_95 < 19.0 else 0.0
+      # We use 17ms as a somewhat looser threshold, instead of 1000.0/60.0.
+      smooth_threshold = 17.0
+      smooth_count = sum(1 for t in frame_times if t < smooth_threshold)
+      percentage_smooth = float(smooth_count) / len(frame_times) * 100.0
     else:
       none_value_reason = NOT_ENOUGH_FRAMES_MESSAGE
     return (
@@ -172,9 +173,8 @@ class SmoothnessMetric(timeline_based_metric.TimelineBasedMetric):
             description='Arithmetic mean of frame times.',
             none_value_reason=none_value_reason),
         scalar.ScalarValue(
-            page, 'mostly_smooth', 'score', mostly_smooth,
-            description='Were 95 percent of the frames hitting 60 fps?'
-                        'boolean value (1/0).',
+            page, 'percentage_smooth', 'score', percentage_smooth,
+            description='Percentage of frames that were hitting 60 fps.',
             none_value_reason=none_value_reason)
     )
 

tools/telemetry/telemetry/web_perf/metrics/smoothness_unittest.py

@@ -153,17 +153,17 @@ class SmoothnessMetricUnitTest(unittest.TestCase):
   def testComputeFrameTimeMetric(self):
     stats = _MockRenderingStats(frame_timestamps=self.good_timestamps,
                                frame_times=[[10, 20], [30, 40, 50]])
-    frame_times_value, mean_frame_time_value, mostly_smooth_value = (
+    frame_times_value, mean_frame_time_value, percentage_smooth_value = (
         self.metric._ComputeFrameTimeMetric(self.page, stats))
     self.assertEquals([10, 20, 30, 40, 50], frame_times_value.values)
     self.assertEquals(30, mean_frame_time_value.value)
-    self.assertEquals(0, mostly_smooth_value.value)
+    self.assertEquals(20, percentage_smooth_value.value)
 
   def testComputeFrameTimeMetricWithNotEnoughFrames(self):
     stats = _MockRenderingStats(
         frame_timestamps=self.not_enough_frames_timestamps,
         frame_times=[[10, 20], [30, 40, 50]])
-    frame_times_value, mean_frame_time_value, mostly_smooth_value = (
+    frame_times_value, mean_frame_time_value, percentage_smooth_value = (
         self.metric._ComputeFrameTimeMetric(self.page, stats))
     self.assertEquals(None, frame_times_value.values)
     self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE,
@@ -171,9 +171,9 @@ class SmoothnessMetricUnitTest(unittest.TestCase):
     self.assertEquals(None, mean_frame_time_value.value)
     self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE,
                       mean_frame_time_value.none_value_reason)
-    self.assertEquals(None, mostly_smooth_value.value)
+    self.assertEquals(None, percentage_smooth_value.value)
     self.assertEquals(smoothness.NOT_ENOUGH_FRAMES_MESSAGE,
-                      mostly_smooth_value.none_value_reason)
+                      percentage_smooth_value.none_value_reason)
 
   def testComputeFrameTimeDiscrepancy(self):
     stats = _MockRenderingStats(frame_timestamps=self.good_timestamps)