telemetry: separated stats collection from metrics calculation.

tools/perf/metrics/smoothness_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 metrics import smoothness
 from telemetry.page import page
 from telemetry.page.page_measurement_results import PageMeasurementResults
 
 class SmoothnessMetricsUnitTest(unittest.TestCase):
 
   def testCalcResultsFromRAFRenderStats(self):
-    rendering_stats = {'droppedFrameCount': 5,
-                       'totalTimeInSeconds': 1,
-                       'numAnimationFrames': 10,
-                       'numFramesSentToScreen': 10}
+    # Create mock BenchmarkStats
+    stats = {'total_time': 1,
+             'screen_frame_count': 10,
+             'dropped_frame_count': 5,
+             'impl_thread_scroll_count': 0,
+             'main_thread_scroll_count': 0,
+             'drawn_layers_count': 0,
+             'missing_tile_count': 0,
+             'texture_upload_count': 0,
+             'texture_upload_time': 0,
+             'commit_count': 0,
+             'commit_time': 0,
+             'deferred_image_decode_count': 0,
+             'deferred_image_decode_time': 0,
+             'deferred_image_cache_hits': 0,
+             'image_gathering_count': 0,
+             'image_gathering_time': 0,
+             'tile_analysis_count': 0,
+             'tile_analysis_time': 0,
+             'solid_color_tile_analysis_count': 0,
+             'input_event_count': 0,
+             'input_event_latency': 0,
+             'touch_ui_count': 0,
+             'touch_ui_latency': 0,
+             'touch_acked_count': 0,
+             'touch_acked_latency': 0,
+             'scroll_update_count': 0,
+             'scroll_update_latency': 0}
+
     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)
     self.assertAlmostEquals(
       100,
       res.page_results[0]['mean_frame_time'].value, 2)
 
   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}
+    # Create mock BenchmarkStats
+    stats = {'total_time': 1.0,
+             'screen_frame_count': 100,
+             'dropped_frame_count': 20,
+             'impl_thread_scroll_count': 50,
+             'main_thread_scroll_count': 50,
+             'drawn_layers_count': 240,
+             'missing_tile_count': 10,
+             'texture_upload_count': 120,
+             'texture_upload_time': 1.2,
+             'commit_count': 130,
+             'commit_time': 1.3,
+             'deferred_image_decode_count': 140,
+             'deferred_image_decode_time': 1.4,
+             'deferred_image_cache_hits': 30,
+             'image_gathering_count': 150,
+             'image_gathering_time': 1.5,
+             'tile_analysis_count': 160,
+             'tile_analysis_time': 1.6,
+             'solid_color_tile_analysis_count': 40,
+             'input_event_count': 170,
+             'input_event_latency': 1.7,
+             'touch_ui_count': 180,
+             'touch_ui_latency': 1.8,
+             'touch_acked_count': 190,
+             'touch_acked_latency': 1.9,
+             'scroll_update_count': 200,
+             'scroll_update_latency': 2.0}
+
     res = PageMeasurementResults()
     res.WillMeasurePage(page.Page('http://foo.com/', None))
-    smoothness.CalcScrollResults(rendering_stats, res)
+    smoothness.CalcResults(stats, res)
     res.DidMeasurePage()
-    self.assertEquals(0, res.page_results[0]['dropped_percent'].value)
+
+    # Scroll Results
     self.assertAlmostEquals(
-      1000 / 60.,
-      res.page_results[0]['mean_frame_time'].value, 2)
+        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(
+        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)
+
+    # 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(
+        2.0 / 200.0 * 1000.0,
+        res.page_results[0]['average_scroll_update_latency'].value)