def __init__(self, overhead_level=NO_OVERHEAD_LEVEL): """As the amount of instrumentation increases, so does the overhead. The user of the measurement chooses the overhead level that is appropriate, and the tracing is filtered accordingly. overhead_level: Can either be a custom TracingCategoryFilter object or one of NO_OVERHEAD_LEVEL, MINIMAL_OVERHEAD_LEVEL or DEBUG_OVERHEAD_LEVEL. """ self._category_filter = None if isinstance(overhead_level, tracing_category_filter.TracingCategoryFilter): self._category_filter = overhead_level elif overhead_level in ALL_OVERHEAD_LEVELS: if overhead_level == NO_OVERHEAD_LEVEL: self._category_filter = tracing_category_filter.CreateNoOverheadFilter( ) elif overhead_level == MINIMAL_OVERHEAD_LEVEL: self._category_filter = ( tracing_category_filter.CreateMinimalOverheadFilter()) else: self._category_filter = ( tracing_category_filter.CreateDebugOverheadFilter()) else: raise Exception( "Overhead level must be a TracingCategoryFilter object" " or valid overhead level string." " Given overhead level: %s" % overhead_level) self._tracing_options = tracing_options.TracingOptions() self._tracing_options.enable_chrome_trace = True self._tracing_options.enable_platform_display_trace = True
def CreateTimelineBasedMeasurementOptions(self): cat_filter = tracing_category_filter.CreateNoOverheadFilter() # blink.console category is required to make sure that Chrome can output # interaction records in its tracing data. cat_filter.AddIncludedCategory('blink.console') cat_filter.AddIncludedCategory('v8') options = timeline_based_measurement.Options(overhead_level=cat_filter) options.SetTimelineBasedMetrics([v8_metric.MessageLoopLatencyMetric()]) return options
def WillNavigateToPage(self, page, tab): self._timeline_controller = timeline_controller.TimelineController( enable_auto_issuing_record=False) if self._report_silk_details: # We need the other traces in order to have any details to report. self._timeline_controller.trace_categories = None else: self._timeline_controller.trace_categories = \ tracing_category_filter.CreateNoOverheadFilter().filter_string self._timeline_controller.SetUp(page, tab)
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 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()) with action_runner.CreateInteraction('InteractionName', **interaction_kwargs): pass 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 SetNoOverheadFilter(self): self._tracing_category_filter = ( tracing_category_filter.CreateNoOverheadFilter())