def WillNavigateToPage(self, page, tab): if not tab.browser.platform.tracing_controller.IsChromeTracingSupported( tab.browser): raise Exception('Not supported') assert self._overhead_level in ALL_OVERHEAD_LEVELS if self._overhead_level == NO_OVERHEAD_LEVEL: category_filter = tracing_category_filter.CreateNoOverheadFilter() # TODO(ernstm): Remove this overhead level when benchmark relevant v8 events # become available in the 'benchmark' category. elif self._overhead_level == V8_OVERHEAD_LEVEL: category_filter = tracing_category_filter.CreateNoOverheadFilter() category_filter.AddIncludedCategory('v8') elif self._overhead_level == MINIMAL_OVERHEAD_LEVEL: category_filter = tracing_category_filter.CreateMinimalOverheadFilter( ) else: category_filter = tracing_category_filter.CreateDebugOverheadFilter( ) for delay in page.GetSyntheticDelayCategories(): category_filter.AddSyntheticDelay(delay) options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start(options, category_filter)
def WillNavigateToPage(self, page, tab): tab.ExecuteJavaScript(""" if (window.chrome && chrome.gpuBenchmarking && chrome.gpuBenchmarking.clearImageCache) { chrome.gpuBenchmarking.clearImageCache(); } """) self._power_metric.Start(page, tab) options = tracing_options.TracingOptions() options.enable_chrome_trace = True # FIXME: Remove the timeline category when impl-side painting is on # everywhere. category_filter = tracing_category_filter.TracingCategoryFilter( 'disabled-by-default-devtools.timeline') # FIXME: Remove webkit.console when blink.console lands in chromium and # the ref builds are updated. crbug.com/386847 # FIXME: Remove the devtools.timeline category when impl-side painting is # on everywhere. categories = [ 'blink', 'devtools.timeline', 'webkit.console', 'blink.console' ] for c in categories: category_filter.AddIncludedCategory(c) tab.browser.platform.tracing_controller.Start(options, category_filter)
def __init__(self, browser_backend, platform_backend, output_path, state, device=None): super(AndroidSystraceProfiler, self).__init__(browser_backend, platform_backend, output_path, state) assert self._browser_backend.supports_tracing self._output_path = output_path + '-trace.zip' self._systrace_output_path = output_path + '.systrace' # Use telemetry's own tracing backend instead the combined mode in # adb_profile_chrome because some benchmarks also do tracing of their own # and the two methods conflict. options = tracing_options.TracingOptions() options.enable_chrome_trace = True self._browser_backend.StartTracing(options, timeout=10) command = [ 'python', os.path.join(util.GetChromiumSrcDir(), 'tools', 'profile_chrome.py'), '--categories', '', '--continuous', '--output', self._systrace_output_path, '--json', '--systrace', ','.join(_SYSTRACE_CATEGORIES) ] if device: command.extend(['--device', device]) self._profiler = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
def testGotTrace(self): options = tracing_options.TracingOptions() options.enable_chrome_trace = True self._tracing_controller.Start( options, tracing_category_filter.TracingCategoryFilter()) trace_data = self._tracing_controller.Stop() # Test that trace data is parsable model.TimelineModel(trace_data)
def WillNavigateToPage(self, page, tab): category_filter = tracing_category_filter.TracingCategoryFilter() for category in self._CATEGORIES: category_filter.AddIncludedCategory(category) options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start( options, category_filter, self._TIME_OUT_IN_SECONDS)
def WillNavigateToPage(self, page, tab): # FIXME: Remove webkit.console when blink.console lands in chromium and the # ref builds are updated. crbug.com/386847 custom_categories = ['webkit.console', 'blink.console', 'gpu'] category_filter = tracing_category_filter.TracingCategoryFilter() for c in custom_categories: category_filter.AddIncludedCategory(c) options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start(options, category_filter, 60)
def StartTracing(self, custom_categories=None, timeout=10): """Note: this function is deprecated. Prefer platform.tracing_controller.""" if not isinstance(custom_categories, tracing_category_filter.TracingCategoryFilter): category_filter = tracing_category_filter.TracingCategoryFilter( filter_string=custom_categories) else: category_filter = custom_categories options = tracing_options.TracingOptions() options.enable_chrome_trace = True return self.platform.tracing_controller.Start( options, category_filter, timeout)
def SetUp(self, page, tab): # FIXME: Remove webkit.console when blink.console lands in chromium and # the ref builds are updated. crbug.com/386847 custom_categories = ['webkit.console', 'blink.console', 'benchmark'] custom_categories += page.GetSyntheticDelayCategories() category_filter = tracing_category_filter.TracingCategoryFilter() for c in custom_categories: category_filter.AddIncludedCategory(c) options = tracing_options.TracingOptions() options.enable_chrome_trace = True options.enable_platform_display_trace = True tab.browser.platform.tracing_controller.Start(options, category_filter, 60)
def testIsTracingRunning(self): tracing_controller = self._browser.platform.tracing_controller if not tracing_controller.IsChromeTracingSupported(self._browser): return self.assertFalse(tracing_controller.is_tracing_running) options = tracing_options.TracingOptions() options.enable_chrome_trace = True category_filter = tracing_category_filter.TracingCategoryFilter() tracing_controller.Start(options, category_filter) self.assertTrue(tracing_controller.is_tracing_running) tracing_controller.Stop() self.assertFalse(tracing_controller.is_tracing_running)
def testGotTrace(self): tracing_controller = self._browser.platform.tracing_controller if not tracing_controller.IsChromeTracingSupported(self._browser): logging.warning('Browser does not support tracing, skipping test.') return self._StartServer() options = tracing_options.TracingOptions() options.enable_chrome_trace = True tracing_controller.Start( options, tracing_category_filter.TracingCategoryFilter()) trace_data = tracing_controller.Stop() # Test that trace data is parsable model.TimelineModel(trace_data)
def __init__(self, browser_backend, platform_backend, output_path, state, categories=None): super(TraceProfiler, self).__init__( browser_backend, platform_backend, output_path, state) assert self._browser_backend.supports_tracing # We always want flow events when tracing via telemetry. categories_with_flow = 'disabled-by-default-toplevel.flow' if categories: categories_with_flow = ',%s' % categories options = tracing_options.TracingOptions() options.enable_chrome_trace = True self._browser_backend.StartTracing( options, categories_with_flow, timeout=10)
def testModifiedConsoleTime(self): category_filter = tracing_category_filter.TracingCategoryFilter() options = tracing_options.TracingOptions() options.enable_chrome_trace = True self._tab.browser.platform.tracing_controller.Start( options, category_filter) self.Navigate('blank.html') self.assertEquals( self._tab.EvaluateJavaScript('document.location.pathname;'), '/blank.html') self._tab.EvaluateJavaScript('console.time = function() { };') with self.assertRaisesRegexp(Exception, 'Page stomped on console.time'): self._tab.browser.platform.tracing_controller.Stop()
def testStartAndStopTraceMultipleTimes(self): options = tracing_options.TracingOptions() options.enable_chrome_trace = True self._tracing_controller.Start( options, tracing_category_filter.TracingCategoryFilter()) self.assertFalse( self._tracing_controller.Start( options, tracing_category_filter.TracingCategoryFilter())) trace_data = self._tracing_controller.Stop() # Test that trace data is parsable model_module.TimelineModel(trace_data) self.assertFalse(self._tracing_controller.is_tracing_running) # Calling stop again will raise exception self.assertRaises(Exception, self._tracing_controller.Stop)
def SetUp(self, page, tab): """Starts gathering timeline data. """ # Resets these member variables incase this object is reused. self._model = None self._renderer_process = None if not tab.browser.platform.tracing_controller.IsChromeTracingSupported(): raise Exception('Not supported') category_filter = tracing_category_filter.TracingCategoryFilter( filter_string=self.trace_categories) for delay in page.GetSyntheticDelayCategories(): category_filter.AddSyntheticDelay(delay) options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start(options, category_filter)
def testGetRendererThreadFromTabId(self): self.assertEquals(self._tab.url, 'about:blank') # Create 3 tabs. The third tab is closed before we call # tracing_controller.Start. first_tab = self._tab second_tab = self._browser.tabs.New() second_tab.Navigate('about:blank') second_tab.WaitForDocumentReadyStateToBeInteractiveOrBetter() third_tab = self._browser.tabs.New() third_tab.Navigate('about:blank') third_tab.WaitForDocumentReadyStateToBeInteractiveOrBetter() third_tab.Close() options = tracing_options.TracingOptions() options.enable_chrome_trace = True self._browser.platform.tracing_controller.Start( options, tracing_category_filter.CreateNoOverheadFilter()) first_tab.ExecuteJavaScript('console.time("first-tab-marker");') first_tab.ExecuteJavaScript('console.timeEnd("first-tab-marker");') second_tab.ExecuteJavaScript('console.time("second-tab-marker");') second_tab.ExecuteJavaScript('console.timeEnd("second-tab-marker");') trace_data = self._browser.platform.tracing_controller.Stop() timeline_model = model.TimelineModel(trace_data) # Assert that the renderer_thread of the first tab contains # 'first-tab-marker'. renderer_thread = timeline_model.GetRendererThreadFromTabId( first_tab.id) first_tab_markers = [ renderer_thread.IterAllSlicesOfName('first-tab-marker') ] self.assertEquals(1, len(first_tab_markers)) # Close second tab and assert that the renderer_thread of the second tab # contains 'second-tab-marker'. second_tab.Close() renderer_thread = timeline_model.GetRendererThreadFromTabId( second_tab.id) second_tab_markers = [ renderer_thread.IterAllSlicesOfName('second-tab-marker') ] self.assertEquals(1, len(second_tab_markers)) # Third tab wasn't available when we start tracing, so there is no # renderer_thread corresponding to it in the the trace. self.assertIs(None, timeline_model.GetRendererThreadFromTabId(third_tab.id))
def testHighlight(self): self.assertEquals(self._tab.url, 'about:blank') options = tracing_options.TracingOptions() options.enable_chrome_trace = True self._browser.platform.tracing_controller.Start( options, tracing_category_filter.CreateNoOverheadFilter()) self._tab.Highlight(rgba_color.WEB_PAGE_TEST_ORANGE) self._tab.ClearHighlight(rgba_color.WEB_PAGE_TEST_ORANGE) trace_data = self._browser.platform.tracing_controller.Stop() timeline_model = model.TimelineModel(trace_data) renderer_thread = timeline_model.GetRendererThreadFromTabId( self._tab.id) found_video_start_event = False for event in renderer_thread.async_slices: if event.name == '__ClearHighlight.video_capture_start': found_video_start_event = True break self.assertTrue(found_video_start_event)
def WillRunUserStory(self, tracing_controller, synthetic_delay_categories=None): """Configure and start tracing. Args: app: an app.App subclass instance. synthetic_delay_categories: iterable of delays. For example: ['DELAY(cc.BeginMainFrame;0.014;alternating)'] where 'cc.BeginMainFrame' is a timeline event, 0.014 is the delay, and 'alternating' is the mode. """ if not tracing_controller.IsChromeTracingSupported(): raise Exception('Not supported') if isinstance(self._tbm_options.overhead_level, tracing_category_filter.TracingCategoryFilter): category_filter = self._tbm_options.overhead_level else: assert self._tbm_options.overhead_level in ALL_OVERHEAD_LEVELS, ( "Invalid TBM Overhead Level: %s" % self._tbm_options.overhead_level) if self._tbm_options.overhead_level == NO_OVERHEAD_LEVEL: category_filter = tracing_category_filter.CreateNoOverheadFilter( ) elif self._tbm_options.overhead_level == MINIMAL_OVERHEAD_LEVEL: category_filter = tracing_category_filter.CreateMinimalOverheadFilter( ) else: category_filter = tracing_category_filter.CreateDebugOverheadFilter( ) for new_category_filter in self._tbm_options.extra_category_filters: category_filter.AddIncludedCategory(new_category_filter) # TODO(slamm): Move synthetic_delay_categories to the TBM options. for delay in synthetic_delay_categories or []: category_filter.AddSyntheticDelay(delay) options = tracing_options.TracingOptions() options.enable_chrome_trace = True options.enable_platform_display_trace = True tracing_controller.Start(options, category_filter)
def VerifyIssuingInteractionRecords(self, **interaction_kwargs): action_runner = action_runner_module.ActionRunner(self._tab, skip_waits=True) self.Navigate('interaction_enabled_page.html') action_runner.Wait(1) options = tracing_options.TracingOptions() options.enable_chrome_trace = True self._browser.platform.tracing_controller.Start( options, tracing_category_filter.CreateNoOverheadFilter()) interaction = action_runner.BeginInteraction('InteractionName', **interaction_kwargs) interaction.End() trace_data = self._browser.platform.tracing_controller.Stop() records = self.GetInteractionRecords(trace_data) self.assertEqual( 1, len(records), 'Failed to issue the interaction record on the tracing timeline.' ' Trace data:\n%s' % repr(trace_data._raw_data)) self.assertEqual('InteractionName', records[0].label) for attribute_name in interaction_kwargs: self.assertTrue(getattr(records[0], attribute_name))
def WillRunUserStory(self, tracing_controller, synthetic_delay_categories=None): """Configure and start tracing. Args: app: an app.App subclass instance. synthetic_delay_categories: iterable of delays. For example: ['DELAY(cc.BeginMainFrame;0.014;alternating)'] where 'cc.BeginMainFrame' is a timeline event, 0.014 is the delay, and 'alternating' is the mode. """ if not tracing_controller.IsChromeTracingSupported(): raise Exception('Not supported') assert self._overhead_level in ALL_OVERHEAD_LEVELS if self._overhead_level == NO_OVERHEAD_LEVEL: category_filter = tracing_category_filter.CreateNoOverheadFilter() # TODO(ernstm): Remove this overhead level when benchmark relevant v8 events # become available in the 'benchmark' category. elif self._overhead_level == V8_OVERHEAD_LEVEL: category_filter = tracing_category_filter.CreateNoOverheadFilter() category_filter.AddIncludedCategory('v8') elif self._overhead_level == MINIMAL_OVERHEAD_LEVEL: category_filter = tracing_category_filter.CreateMinimalOverheadFilter() else: category_filter = tracing_category_filter.CreateDebugOverheadFilter() for new_category_filter in self._category_filters: category_filter.AddIncludedCategory(new_category_filter) # TODO(slamm): Move synthetic_delay_categories to the TBM options. for delay in synthetic_delay_categories or []: category_filter.AddSyntheticDelay(delay) options = tracing_options.TracingOptions() options.enable_chrome_trace = True options.enable_platform_display_trace = True tracing_controller.Start(options, category_filter)
def WillNavigateToPage(self, page, tab): options = tracing_options.TracingOptions() options.enable_chrome_trace = True category_filter = tracing_category_filter.TracingCategoryFilter( 'disabled-by-default-cc.debug.cdp-perf') tab.browser.platform.tracing_controller.Start(options, category_filter)
options = browser_options.BrowserFinderOptions(); parser = options.CreateParser(); (_, args) = parser.parse_args(); browserFactory = browser_finder.FindBrowser(options); with browserFactory.Create(options) as browser: tab = browser.tabs.New(); tab.Activate(); for i in browser.tabs: if i == tab.id: continue browser.tabs.GetTabById(i).Close() category_filter = tracing_category_filter.TracingCategoryFilter() options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.Navigate(args[0]); tab.WaitForDocumentReadyStateToBeComplete(); oldDisplay = tab.EvaluateJavaScript("document.documentElement.style.display"); browser.platform.tracing_controller.Start(options, category_filter); iterations = 1 if len(args) == 2: iterations = int(args[1]) for i in range(iterations): tab.EvaluateJavaScript("(function() { document.documentElement.style.display = 'none'; return document.documentElement.offsetTop; })()"); tab.EvaluateJavaScript("(function() { document.documentElement.style.display = '" + oldDisplay + "'; console.time('iteration" + str(i) + "'); var x = document.documentElement.offsetTop; console.timeEnd('iteration" + str(i) + "'); })()"); browser.platform.tracing_controller.Stop().Serialize(sys.stdout);
def WillNavigateToPage(self, page, tab): cat_string = ','.join(TOPLEVEL_CATEGORIES) cat_filter = tracing_category_filter.TracingCategoryFilter(cat_string) options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start(options, cat_filter, 60)
def WillRunActions(self, _page, tab): options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start( options, tracing_category_filter.TracingCategoryFilter())