def DidRunActions(self, page, tab): trace_data = tab.browser.platform.tracing_controller.Stop() timeline_model = TimelineModel(trace_data) self._renderer_process = timeline_model.GetRendererProcessFromTabId( tab.id) self._browser_process = timeline_model.browser_process
def ValidateAndMeasurePage(self, page, tab, results): del page # unused trace_data = tab.browser.platform.tracing_controller.StopTracing()[0] timeline_model = TimelineModel(trace_data) renderer_process = timeline_model.GetRendererProcessFromTabId(tab.id) self._AddV8MetricsToResults(renderer_process, results)
def ValidateAndMeasurePage(self, page, tab, results): trace_data = tab.browser.platform.tracing_controller.StopTracing() timeline_model = TimelineModel(trace_data) self._renderer_process = timeline_model.GetRendererProcessFromTabId( tab.id) self._browser_process = timeline_model.browser_process self._AddResults(results)
def ValidateAndMeasurePage(self, page, tab, results): del page # unused trace_data = tab.browser.platform.tracing_controller.StopTracing() # TODO(charliea): This is part of a three-sided Chromium/Telemetry patch # where we're changing the return type of StopTracing from a TraceValue to a # (TraceValue, nonfatal_exception_list) tuple. Once the tuple return value # lands in Chromium, the non-tuple logic should be deleted. if isinstance(trace_data, tuple): trace_data = trace_data[0] timeline_model = TimelineModel(trace_data) renderer_process = timeline_model.GetRendererProcessFromTabId(tab.id) self._AddV8MetricsToResults(renderer_process, results)
class TimelineController(object): def __init__(self): super(TimelineController, self).__init__() self.trace_categories = None self._model = None self._renderer_process = None self._smooth_records = [] self._interaction = None 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 Start(self, tab): # Start the smooth marker for all actions. runner = action_runner.ActionRunner(tab) self._interaction = runner.CreateInteraction( RUN_SMOOTH_ACTIONS) self._interaction.Begin() def Stop(self, tab, results): # End the smooth marker for all actions. self._interaction.End() # Stop tracing. timeline_data = tab.browser.platform.tracing_controller.Stop() results.AddValue(trace.TraceValue( results.current_page, timeline_data)) self._model = TimelineModel(timeline_data) self._renderer_process = self._model.GetRendererProcessFromTabId(tab.id) renderer_thread = self.model.GetRendererThreadFromTabId(tab.id) run_smooth_actions_record = None self._smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.label == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'TimelineController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r else: self._smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self.model, r)) # If there is no other smooth records, we make measurements on time range # marked by timeline_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(self._smooth_records) == 0 and run_smooth_actions_record: self._smooth_records = [run_smooth_actions_record] def CleanUp(self, tab): if tab.browser.platform.tracing_controller.is_tracing_running: tab.browser.platform.tracing_controller.Stop() @property def model(self): return self._model @property def renderer_process(self): return self._renderer_process @property def smooth_records(self): return self._smooth_records
class TimelineController(object): def __init__(self, enable_auto_issuing_record=True): super(TimelineController, self).__init__() self.trace_categories = None self._model = None self._renderer_process = None self._smooth_records = [] self._interaction = None self._enable_auto_issuing_record = enable_auto_issuing_record def SetUp(self, page, tab): """Starts gathering timeline data. """ del page # unused # 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') config = tracing_config.TracingConfig() config.chrome_trace_config.category_filter.AddFilterString( self.trace_categories) config.enable_chrome_trace = True tab.browser.platform.tracing_controller.StartTracing(config) def Start(self, tab): # Start the smooth marker for all actions. if self._enable_auto_issuing_record: self._interaction = tab.action_runner.CreateInteraction( RUN_SMOOTH_ACTIONS) self._interaction.Begin() def Stop(self, tab, results): # End the smooth marker for all actions. if self._enable_auto_issuing_record: self._interaction.End() # Stop tracing. timeline_data = tab.browser.platform.tracing_controller.StopTracing() # TODO(#763375): Rely on results.telemetry_info.trace_local_path/etc. kwargs = {} if hasattr(results.telemetry_info, 'trace_local_path'): kwargs['file_path'] = results.telemetry_info.trace_local_path kwargs['remote_path'] = results.telemetry_info.trace_remote_path kwargs['upload_bucket'] = results.telemetry_info.upload_bucket kwargs['cloud_url'] = results.telemetry_info.trace_remote_url results.AddValue( trace.TraceValue(results.current_page, timeline_data, **kwargs)) self._model = TimelineModel(timeline_data) self._renderer_process = self._model.GetRendererProcessFromTabId( tab.id) renderer_thread = self.model.GetRendererThreadFromTabId(tab.id) run_smooth_actions_record = None self._smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.label == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'TimelineController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r else: self._smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self.model, r)) # If there is no other smooth records, we make measurements on time range # marked by timeline_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(self._smooth_records) == 0 and run_smooth_actions_record: self._smooth_records = [run_smooth_actions_record] if len(self._smooth_records) == 0: raise legacy_page_test.Failure( 'No interaction record was created.') def CleanUp(self, platform): if platform.tracing_controller.is_tracing_running: platform.tracing_controller.StopTracing() @property def model(self): return self._model @property def renderer_process(self): return self._renderer_process @property def smooth_records(self): return self._smooth_records
class TimelineController(object): def __init__(self): super(TimelineController, self).__init__() self.trace_categories = tracing_backend.DEFAULT_TRACE_CATEGORIES self._model = None self._renderer_process = None self._smooth_records = [] self._interaction = None def Start(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.supports_tracing: raise Exception('Not supported') if self.trace_categories: categories = [self.trace_categories] + \ page.GetSyntheticDelayCategories() else: categories = page.GetSyntheticDelayCategories() tab.browser.StartTracing(','.join(categories)) # Start the smooth marker for all actions. runner = action_runner.ActionRunner(tab) self._interaction = runner.BeginInteraction(RUN_SMOOTH_ACTIONS, is_smooth=True) def Stop(self, tab): # End the smooth marker for all actions. self._interaction.End() # Stop tracing. timeline_data = tab.browser.StopTracing() self._model = TimelineModel(timeline_data) self._renderer_process = self._model.GetRendererProcessFromTabId( tab.id) renderer_thread = self.model.GetRendererThreadFromTabId(tab.id) run_smooth_actions_record = None self._smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.logical_name == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'TimelineController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r elif r.is_smooth: self._smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self.model, r)) # If there is no other smooth records, we make measurements on time range # marked by timeline_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(self._smooth_records) == 0 and run_smooth_actions_record: self._smooth_records = [run_smooth_actions_record] def CleanUp(self, tab): if tab.browser.is_tracing_running: tab.browser.StopTracing() @property def model(self): return self._model @property def renderer_process(self): return self._renderer_process @property def smooth_records(self): return self._smooth_records