Telemetry: re-enable cpu metric for page_cycler.

tools/perf/measurements/page_cycler_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.core import browser_options
 from telemetry.page import page_measurement_results
 from telemetry.page import page_runner
 from telemetry.unittest import simple_mock
@@ skipping 35 matching lines @@
     self.clear_cache_calls = 0
   def ClearCache(self, force=False):
     assert force
     self.clear_cache_calls += 1
   def EvaluateJavaScript(self, _):
     return 1
   def WaitForJavaScriptExpression(self, _, __):
     pass
 
 
+class FakeBrowser(object):
+  _iteration = 0
+
+  @property
+  def cpu_stats(self):
+    FakeBrowser._iteration += 1
+    return {
+        'Browser': {'CpuProcessTime': FakeBrowser._iteration,
+                    'TotalTime': FakeBrowser._iteration * 2},
+        'Renderer': {'CpuProcessTime': FakeBrowser._iteration,
+                    'TotalTime': FakeBrowser._iteration * 3},
+        'Gpu': {'CpuProcessTime': FakeBrowser._iteration,
+                 'TotalTime': FakeBrowser._iteration * 4}
+    }
+
+
 class PageCyclerUnitTest(unittest.TestCase):
 
   def SetUpCycler(self, args, setup_memory_module=False):
     cycler = page_cycler.PageCycler()
     options = browser_options.BrowserFinderOptions()
     parser = options.CreateParser()
     page_runner.AddCommandLineArgs(parser)
     cycler.AddCommandLineArgs(parser)
     cycler.SetArgumentDefaults(parser)
     parser.parse_args(args)
     page_runner.ProcessCommandLineArgs(parser, options)
     cycler.ProcessCommandLineArgs(parser, options)
     cycler.CustomizeBrowserOptions(options)
 
     if setup_memory_module:
       # Mock out memory metrics; the real ones require a real browser.
       mock_memory_metric = MockMemoryMetric()
 
       mock_memory_module = simple_mock.MockObject()
       mock_memory_module.ExpectCall(
         'MemoryMetric').WithArgs(simple_mock.DONT_CARE).WillReturn(
         mock_memory_metric)
 
       real_memory_module = page_cycler.memory
       try:
         page_cycler.memory = mock_memory_module
-        cycler.DidStartBrowser(None)
+        cycler.DidStartBrowser(FakeBrowser())
       finally:
         page_cycler.memory = real_memory_module
 
     return cycler
 
   def testOptionsColdLoadNoArgs(self):
     cycler = self.SetUpCycler([])
 
     self.assertEquals(cycler._cold_run_start_index, 5)
 
@@ skipping 22 matching lines @@
       cycler.WillNavigateToPage(page, tab)
       self.assertEqual(max(0, i - 2), tab.clear_cache_calls,
                        "Iteration %d tab.clear_cache_calls %d" %
                        (i, tab.clear_cache_calls))
       results.WillMeasurePage(page)
       cycler.MeasurePage(page, tab, results)
 
       values = results.page_specific_values_for_current_page
       results.DidMeasurePage()
 
-      self.assertEqual(1, len(values))
+      self.assertEqual(4, len(values))
       self.assertEqual(values[0].page, page)

[bulach, 2014/04/23 17:11:47]

please advise: note that here and the test below, it had already broken the
principle you mentioned as these are not truly "unit", they're larger sort of
integration-type tests..

I'm happy to consolidate (141-147) and (171-181) together in its own test if you
prefer.

as for he values themselves: happy to test if you prefer, but as you said, the
actual computation is deeper down in metrics/cpu..

please let me know your thoughts!

[qyearsley, 2014/04/23 18:13:38]

My thoughts are that this CL LGTM as is. But, in theory, the test would be
easier to understand if it were re-organized so that one test method tests only
one thing. Perhaps outside of the scope of this CL.

[bulach, 2014/04/24 08:57:00]

sgtm! I'll CQ this as is and send you a separate CL shortly splitting the  tests
shortly.

+      self.assertEqual(values[1].name,
+          'cpu_utilization.cpu_utilization_gpu')
+      self.assertEqual(values[2].name,
+          'cpu_utilization.cpu_utilization_renderer')
+      self.assertEqual(values[3].name,
+          'cpu_utilization.cpu_utilization_browser')
+
 
       chart_name = 'cold_times' if i == 0 or i > 2 else 'warm_times'
       self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
       self.assertEqual(values[0].units, 'ms')
 
       cycler.DidNavigateToPage(page, tab)
 
   def testColdWarm(self):
     cycler = self.SetUpCycler(['--pageset-repeat=3'], True)
     pages = [FakePage("http://fakepage1.com"), FakePage("http://fakepage2.com")]
     tab = FakeTab()
     results = page_measurement_results.PageMeasurementResults()
     for i in range(3):
       for page in pages:
         cycler.WillNavigateToPage(page, tab)
         results.WillMeasurePage(page)
         cycler.MeasurePage(page, tab, results)
 
         values = results.page_specific_values_for_current_page
         results.DidMeasurePage()
 
-        self.assertEqual(1, len(values))
+        self.assertEqual(4, len(values))
         self.assertEqual(values[0].page, page)
 
         chart_name = 'cold_times' if i == 0 or i > 1 else 'warm_times'
         self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
+        self.assertEqual(values[1].name,
+            'cpu_utilization.cpu_utilization_gpu')
+        self.assertEqual(values[2].name,
+            'cpu_utilization.cpu_utilization_renderer')
+        self.assertEqual(values[3].name,
+            'cpu_utilization.cpu_utilization_browser')
 
         cycler.DidNavigateToPage(page, tab)