telemetry: separated stats collection from metrics calculation.

tools/perf/metrics/smoothness_unittest.py

Index: tools/perf/metrics/smoothness_unittest.py
diff --git a/tools/perf/metrics/smoothness_unittest.py b/tools/perf/metrics/smoothness_unittest.py
index e7b8778e94b8102efe98d4975b6a92f72718cc9e..2a42f9dd24e39b71792dc1934b87ab0ed74ed406 100644
--- a/tools/perf/metrics/smoothness_unittest.py
+++ b/tools/perf/metrics/smoothness_unittest.py
@@ -4,43 +4,110 @@
 import unittest
 
 from metrics import smoothness
+from metrics.gpu_rendering_stats import GpuRenderingStats
 from telemetry.page import page
 from telemetry.page.page_measurement_results import PageMeasurementResults
 
 class SmoothnessMetricsUnitTest(unittest.TestCase):
+  def testCalcResultsRealRenderStats(self):
+    mock_rendering_stats_deltas = {
+        'totalTimeInSeconds': 1.0,
+        'numFramesSentToScreen': 100,
+        'droppedFrameCount': 20,
+        'numImplThreadScrolls': 50,
+        'numMainThreadScrolls': 50,
+        'numLayersDrawn': 240,
+        'numMissingTiles': 10,
+        'textureUploadCount': 120,
+        'totalTextureUploadTimeInSeconds': 1.2,
+        'totalCommitCount': 130,
+        'totalCommitTimeInSeconds': 1.3,
+        'totalDeferredImageDecodeCount': 140,
+        'totalDeferredImageDecodeTimeInSeconds': 1.4,
+        'totalDeferredImageCacheHitCount': 30,
+        'totalImageGatheringCount': 150,
+        'totalImageGatheringTimeInSeconds': 1.5,
+        'totalTilesAnalyzed': 160,
+        'totalTileAnalysisTimeInSeconds': 1.6,
+        'solidColorTilesAnalyzed': 40,
+        'inputEventCount': 170,
+        'totalInputLatency': 1.7,
+        'touchUICount': 180,
+        'totalTouchUILatency': 1.8,
+        'touchAckedCount': 190,
+        'totalTouchAckedLatency': 1.9,
+        'scrollUpdateCount': 200,
+        'totalScrollUpdateLatency': 2.0}
+    stats = GpuRenderingStats(mock_rendering_stats_deltas)
 
-  def testCalcResultsFromRAFRenderStats(self):
-    rendering_stats = {'droppedFrameCount': 5,
-                       'totalTimeInSeconds': 1,
-                       'numAnimationFrames': 10,
-                       'numFramesSentToScreen': 10}
     res = PageMeasurementResults()
     res.WillMeasurePage(page.Page('http://foo.com/', None))
-    smoothness.CalcScrollResults(rendering_stats, res)
+    smoothness.CalcResults(stats, res)
     res.DidMeasurePage()
-    self.assertEquals(50, res.page_results[0]['dropped_percent'].value)
+
+    # Scroll Results
+    self.assertAlmostEquals(
+        1.0 / 100.0 * 1000.0,
+        res.page_results[0]['mean_frame_time'].value, 2)
+    self.assertAlmostEquals(
+        20.0 / 100.0 * 100.0,
+        res.page_results[0]['dropped_percent'].value)
+    self.assertAlmostEquals(
+        50.0 / (50.0 + 50.0) * 100.0,
+        res.page_results[0]['percent_impl_scrolled'].value)
     self.assertAlmostEquals(
-      100,
-      res.page_results[0]['mean_frame_time'].value, 2)
+        240.0 / 100.0,
+        res.page_results[0]['average_num_layers_drawn'].value)
+    self.assertAlmostEquals(
+        10.0 / 100.0,
+        res.page_results[0]['average_num_missing_tiles'].value)
 
-  def testCalcResultsRealRenderStats(self):
-    rendering_stats = {'numFramesSentToScreen': 60,
-                       'globalTotalTextureUploadTimeInSeconds': 0,
-                       'totalProcessingCommandsTimeInSeconds': 0,
-                       'globalTextureUploadCount': 0,
-                       'droppedFrameCount': 0,
-                       'textureUploadCount': 0,
-                       'numAnimationFrames': 10,
-                       'totalPaintTimeInSeconds': 0.35374299999999986,
-                       'globalTotalProcessingCommandsTimeInSeconds': 0,
-                       'totalTextureUploadTimeInSeconds': 0,
-                       'totalRasterizeTimeInSeconds': 0,
-                       'totalTimeInSeconds': 1.0}
-    res = PageMeasurementResults()
-    res.WillMeasurePage(page.Page('http://foo.com/', None))
-    smoothness.CalcScrollResults(rendering_stats, res)
-    res.DidMeasurePage()
-    self.assertEquals(0, res.page_results[0]['dropped_percent'].value)
+    # Texture Upload Results
+    self.assertAlmostEquals(
+        1.3 / 130.0 * 1000.0,
+        res.page_results[0]['average_commit_time'].value)
+    self.assertEquals(
+        120,
+        res.page_results[0]['texture_upload_count'].value)
+    self.assertEquals(
+        1.2,
+        res.page_results[0]['total_texture_upload_time'].value)
+
+    # Image Decoding Results
+    self.assertEquals(
+        140,
+        res.page_results[0]['total_deferred_image_decode_count'].value)
+    self.assertEquals(
+        30,
+        res.page_results[0]['total_image_cache_hit_count'].value)
+    self.assertAlmostEquals(
+        1.5 / 150.0 * 1000.0,
+        res.page_results[0]['average_image_gathering_time'].value)
+    self.assertEquals(
+        1.4,
+        res.page_results[0]['total_deferred_image_decoding_time'].value)
+
+    # Tile Analysis Results
+    self.assertEquals(
+        160,
+        res.page_results[0]['total_tiles_analyzed'].value)
+    self.assertEquals(
+        40,
+        res.page_results[0]['solid_color_tiles_analyzed'].value)
+    self.assertAlmostEquals(
+        1.6 / 160.0 * 1000.0,
+        res.page_results[0]['average_tile_analysis_time'].value)
+
+    # Latency Results
+    self.assertAlmostEquals(
+        1.7 / 170.0 * 1000.0,
+        res.page_results[0]['average_latency'].value)
+    self.assertAlmostEquals(
+        1.8 / 180.0 * 1000.0,
+        res.page_results[0]['average_touch_ui_latency'].value)
+    self.assertAlmostEquals(
+        1.9 / 190.0 * 1000.0,
+        res.page_results[0]['average_touch_acked_latency'].value)
     self.assertAlmostEquals(
-      1000 / 60.,
-      res.page_results[0]['mean_frame_time'].value, 2)
+        2.0 / 200.0 * 1000.0,
+        res.page_results[0]['average_scroll_update_latency'].value)