sandwich: Make speed-index and memory measurement optional from run-all

tools/android/loading/sandwich_metrics_unittest.py

 # Copyright 2016 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 copy
 import json
 import os
 import shutil
 import subprocess
 import tempfile
 import unittest
 
 import loading_trace
 import page_track
 import sandwich_metrics as puller
 import sandwich_runner
 import request_track
 import tracing
 
 
 _BLINK_CAT = 'blink.user_timing'
-_MEM_CAT = 'disabled-by-default-memory-infra'
+_MEM_CAT = sandwich_runner.MEMORY_DUMP_CATEGORY
 _START='requestStart'
 _LOADS='loadEventStart'
 _LOADE='loadEventEnd'
 _UNLOAD='unloadEventEnd'
 
 _MINIMALIST_TRACE_EVENTS = [
     {'ph': 'R', 'cat': _BLINK_CAT, 'name': _UNLOAD, 'ts': 10000,
         'args': {'frame': '0'}},
     {'ph': 'R', 'cat': _BLINK_CAT, 'name': _START,  'ts': 20000,
         'args': {}},
     {'cat': _MEM_CAT,   'name': 'periodic_interval', 'pid': 1, 'ph': 'v',
         'ts': 1, 'args': {'dumps': {'allocators': {'malloc': {'attrs': {'size':{
             'units': 'bytes', 'value': '1af2', }}}}}}},
     {'ph': 'R', 'cat': _BLINK_CAT, 'name': _LOADS,  'ts': 35000,
         'args': {'frame': '0'}},
     {'ph': 'R', 'cat': _BLINK_CAT, 'name': _LOADE,  'ts': 40000,
         'args': {'frame': '0'}},
     {'cat': _MEM_CAT,   'name': 'periodic_interval', 'pid': 1, 'ph': 'v',
         'ts': 1, 'args': {'dumps': {'allocators': {'malloc': {'attrs': {'size':{
             'units': 'bytes', 'value': 'd704', }}}}}}},
     {'ph': 'M', 'cat': '__metadata', 'pid': 1, 'name': 'process_name', 'ts': 1,
         'args': {'name': 'Browser'}}]
 
 
 def TracingTrack(events):
   return tracing.TracingTrack.FromJsonDict({
       'events': events,
       'categories': (tracing.INITIAL_CATEGORIES +
-          sandwich_runner.ADDITIONAL_CATEGORIES)})
+          (sandwich_runner.MEMORY_DUMP_CATEGORY,))})
 
 
 def LoadingTrace(events):
   return loading_trace.LoadingTrace('http://a.com/', {},
                                     page_track.PageTrack(None),
                                     request_track.RequestTrack(None),
                                     TracingTrack(events))
 
 
 class PageTrackTest(unittest.TestCase):
@@ skipping 38 matching lines @@
         {'pid': 123, 'ts':  4000, 'cat': _MEM_CAT, 'ph': 'v', 'name': 'foo'},
         {'pid': 123, 'ts':  5000, 'cat': _MEM_CAT, 'ph': 'v', 'name': NAME},
         {'pid': 123, 'ts':  6000, 'cat': _MEM_CAT, 'ph': 'V'},
         {'pid': 672, 'ts':  7000, 'cat': _MEM_CAT, 'ph': 'v', 'name': NAME},
         {'pid': 354, 'ts':  8000, 'cat': _MEM_CAT, 'ph': 'v', 'name': 'foo'},
         {'pid': 123, 'ts':  9000, 'cat': 'whatever1', 'ph': 'v', 'name': NAME},
         {'pid': 123, 'ts': 10000, 'cat': _MEM_CAT, 'ph': 'v', 'name': NAME},
         {'pid': 354, 'ts': 11000, 'cat': 'whatever0', 'ph': 'R'},
         {'pid': 672, 'ts': 12000, 'cat': _MEM_CAT, 'ph': 'v', 'name': NAME}]
 
-    self.assertTrue(_MEM_CAT in sandwich_runner.ADDITIONAL_CATEGORIES)
-
     bump_events = RunHelper(TRACE_EVENTS, 123)
     self.assertEquals(2, len(bump_events))
     self.assertEquals(5, bump_events[0].start_msec)
     self.assertEquals(10, bump_events[1].start_msec)
 
     bump_events = RunHelper(TRACE_EVENTS, 354)
     self.assertEquals(1, len(bump_events))
     self.assertEquals(1, bump_events[0].start_msec)
 
     bump_events = RunHelper(TRACE_EVENTS, 672)
@@ skipping 58 matching lines @@
         {'ph': 'R', 'ts': 24000, 'args': {'frame': '0'}, 'cat': _BLINK_CAT,
             'name': _LOADS},
         {'ph': 'R', 'ts': 25000, 'args': {'frame': '0'}, 'cat': _BLINK_CAT,
             'name': _LOADE}]))
 
     self.assertEquals(3, len(trace_events))
     self.assertEquals(14, trace_events['requestStart'].start_msec)
     self.assertEquals(17, trace_events['loadEventStart'].start_msec)
     self.assertEquals(19, trace_events['loadEventEnd'].start_msec)
 
-  def testPullMetricsFromLoadingTrace(self):
-    metrics = puller._ExtractMetricsFromLoadingTrace(LoadingTrace(
+  def testExtractDefaultMetrics(self):
+    metrics = puller._ExtractDefaultMetrics(LoadingTrace(
         _MINIMALIST_TRACE_EVENTS))
-    self.assertEquals(4, len(metrics))
+    self.assertEquals(2, len(metrics))
     self.assertEquals(20, metrics['total_load'])
     self.assertEquals(5, metrics['js_onload_event'])
+
+  def testExtractMemoryMetrics(self):
+    metrics = puller._ExtractMemoryMetrics(LoadingTrace(
+        _MINIMALIST_TRACE_EVENTS))
+    self.assertEquals(2, len(metrics))
     self.assertEquals(30971, metrics['browser_malloc_avg'])
     self.assertEquals(55044, metrics['browser_malloc_max'])
 
   def testComputeSpeedIndex(self):
     def point(time, frame_completeness):
       return puller.CompletenessPoint(time=time,
                                       frame_completeness=frame_completeness)
     completness_record = [
       point(0, 0.0),
       point(120, 0.4),
@@ skipping 32 matching lines @@
 
     process = subprocess.Popen(['python', puller.__file__, tmp_dir])
     process.wait()
     shutil.rmtree(tmp_dir)
 
     self.assertEquals(0, process.returncode)
 
 
 if __name__ == '__main__':
   unittest.main()