[telemetry] Implement first version of timeline based measurement

tools/perf/measurements/meta_measurement_unittest.py

Index: tools/perf/measurements/meta_measurement_unittest.py
diff --git a/tools/perf/measurements/meta_measurement_unittest.py b/tools/perf/measurements/meta_measurement_unittest.py
new file mode 100644
index 0000000000000000000000000000000000000000..77b4ee31b75a3dd28d36b4795c275f809a53f614
--- /dev/null
+++ b/tools/perf/measurements/meta_measurement_unittest.py
@@ -0,0 +1,125 @@
+# Copyright 2014 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 os
+import unittest
+
+from measurements import meta_measurement
+from metrics import timeline_based_metric
+from telemetry.core import wpr_modes
+from telemetry.core.timeline import model as model_module
+from telemetry.core.timeline import async_slice
+from telemetry.page import page_measurement_results
+from telemetry.page import page_measurement_unittest_base
+from telemetry.page import page_set
+from telemetry.unittest import options_for_unittests
+
+class ParseTests(unittest.TestCase):
+  def testParse(self):
+    self.assertTrue(meta_measurement.IsMetricRequest("MetricRequest.Foo/Bar"))
+    self.assertFalse(meta_measurement.IsMetricRequest("SomethingRandom"))
+
+    self.assertEquals(
+        ('MetricType', 'LogicalName'),
+        meta_measurement.ParseMetricRequest(
+            "MetricRequest.MetricType/LogicalName"))
+
+    self.assertEquals(
+        ('MetricType', 'LogicalNameWith/Slash'),
+        meta_measurement.ParseMetricRequest(
+            "MetricRequest.MetricType/LogicalNameWith/Slash"))
+
+class MetaMetricsTests(unittest.TestCase):
+  def setUp(self):
+    model = model_module.TimelineModel()
+    renderer_thread = model.GetOrCreateProcess(1).GetOrCreateThread(2)
+    renderer_thread.name = 'CrRendererMain'
+
+    # [      X       ]
+    #      [  Y  ]
+    renderer_thread.BeginSlice('cat1', 'x.y', 10, 0)
+    renderer_thread.EndSlice(20, 20)
+
+    renderer_thread.async_slices.append(async_slice.AsyncSlice(
+        'cat', 'MetricRequest.MetricType1/LogicalName1',
+        timestamp=0, duration=20,
+        start_thread=renderer_thread, end_thread=renderer_thread))
+    renderer_thread.async_slices.append(async_slice.AsyncSlice(
+        'cat', 'MetricRequest.MetricType2/LogicalName2',
+        timestamp=25, duration=5,
+        start_thread=renderer_thread, end_thread=renderer_thread))
+    model.FinalizeImport()
+
+    self.model = model
+    self.renderer_thread = renderer_thread
+
+  def testFindMetricRequests(self):
+    metric = meta_measurement._MetaMetrics( # pylint: disable=W0212
+        self.model, self.renderer_thread,
+        detailed_mode=False)
+    requests = metric.FindMetricRequests()
+    self.assertEquals(2, len(requests))
+    self.assertEquals('MetricType1', requests[0].metric_type)
+    self.assertEquals(0, requests[0].start)
+    self.assertEquals(20, requests[0].end)
+
+    self.assertEquals('MetricType2', requests[1].metric_type)
+    self.assertEquals(25, requests[1].start)
+    self.assertEquals(30, requests[1].end)
+
+  def testAddResults(self):
+    results = page_measurement_results.PageMeasurementResults()
+    class Metric1(timeline_based_metric.TimelineBasedMetric):
+      def AddResults(self, model, renderer_thread,
+                     metric_request, results, detailed_mode=False):
+        results.Add(metric_request.GetResultNameFor('Metric1'), 'ms', 1)
+
+    class Metric2(timeline_based_metric.TimelineBasedMetric):
+      def AddResults(self, model, renderer_thread,
+                     metric_request, results, detailed_mode=False):
+        assert metric_request.logical_name == 'LogicalName2'
+        results.Add(metric_request.GetResultNameFor('Metric2'), 'ms', 2)
+
+    class MetaMetricsWithFakeMetricHandler(
+        meta_measurement._MetaMetrics): # pylint: disable=W0212
+      def CreateMetricsForMetricRequest(self, request):
+        cls = {'MetricType1': Metric1,
+               'MetricType2': Metric2}[request.metric_type]
+        return [cls()]
+
+    metric = MetaMetricsWithFakeMetricHandler(
+        self.model, self.renderer_thread,
+        detailed_mode=False)
+    ps = page_set.PageSet.FromDict({
+      "description": "hello",
+      "archive_path": "foo.wpr",
+      "pages": [
+        {"url": "http://www.bar.com/"}
+      ]
+    }, os.path.dirname(__file__))
+    results.WillMeasurePage(ps.pages[0])
+    metric.AddResults(results)
+    results.DidMeasurePage()
+
+    v = results.FindAllPageSpecificValuesNamed('LogicalName1/Metric1')
+    self.assertEquals(len(v), 1)
+    v = results.FindAllPageSpecificValuesNamed('LogicalName2/Metric2')
+    self.assertEquals(len(v), 1)
+
+
+class MetaMeasurementTest(
+      page_measurement_unittest_base.PageMeasurementUnitTestBase):
+  def setUp(self):
+    self._options = options_for_unittests.GetCopy()
+    self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
+
+  def testMetaForSmoke(self):
+    ps = self.CreatePageSetFromFileInUnittestDataDir(
+        'measurement_request_enabled_page.html')
+    setattr(ps.pages[0], 'smoothness', {'action': 'wait',
+                                        'javascript': 'window.animationDone'})
+    measurement = meta_measurement.MetaMeasurement()
+    results = self.RunMeasurement(measurement, ps,
+                                  options=self._options)
+    self.assertEquals(0, len(results.failures))