def MeasurePage(self, page, tab, results): if not hasattr(self.options, 'x'): raise page_measurement.MeasurementFailure('Default option was not set.') if self.options.x != 3: raise page_measurement.MeasurementFailure( 'Expected x == 3, got x == ' + self.options.x) results.Add('x', 'ms', 7)
def Stop(self, page, tab): if self._mode == TRACING_MODE: # This creates an async trace event in the render process for tab that # will allow us to find that tab during the AddTracingResultsForTab # function. success = tab.EvaluateJavaScript(""" console.time("__loading_measurement_was_here__"); console.timeEnd("__loading_measurement_was_here__"); console.time.toString().indexOf('[native code]') != -1; """) trace_result = tab.browser.StopTracing() if not success: raise page_measurement.MeasurementFailure( 'Page stomped on console.time') self._model = trace_result.AsTimelineModel() events = [ s for s in self._model.GetAllEventsOfName( '__loading_measurement_was_here__') if s.parent_slice == None ] assert len( events) == 1, 'Expected one marker, got %d' % len(events) # TODO(tonyg): This should be threads_for_tab and report events for both # the starting thread and ending thread. self._thread_for_tab = events[0].start_thread else: tab.StopTimelineRecording() self._model = tab.timeline_model self._thread_for_tab = self._model.GetAllThreads()[0]
def AddResults(self, tab, results): # Map a page name to its AddResults func. page_to_metrics = { 'header validation': [self._metrics.AddResultsForHeaderValidation], 'compression: image': [ self._metrics.AddResultsForHeaderValidation, self._metrics.AddResultsForDataSaving, ], 'compression: javascript': [ self._metrics.AddResultsForHeaderValidation, self._metrics.AddResultsForDataSaving, ], 'compression: css': [ self._metrics.AddResultsForHeaderValidation, self._metrics.AddResultsForDataSaving, ], 'bypass': [self._metrics.AddResultsForBypass], 'safebrowsing': [self._metrics.AddResultsForSafebrowsing], } if not self._page.name in page_to_metrics: raise page_measurement.MeasurementFailure( 'Invalid page name (%s) in smoke. Page name must be one of:\n%s' % (self._page.name, page_to_metrics.keys())) for add_result in page_to_metrics[self._page.name]: add_result(tab, results)
def WillRunActions(self, page, tab): tab.WaitForDocumentReadyStateToBeComplete() self._smoothness_controller = smoothness_controller.SmoothnessController( ) self._smoothness_controller.Start(page, tab) # Rasterize only what's visible. tab.ExecuteJavaScript( 'chrome.gpuBenchmarking.setRasterizeOnlyVisibleContent();') args = {} args['mode'] = self.options.mode if self.options.width: args['width'] = self.options.width if self.options.height: args['height'] = self.options.height # Enque benchmark tab.ExecuteJavaScript(""" window.benchmark_results = {}; window.benchmark_results.id = chrome.gpuBenchmarking.runMicroBenchmark( "invalidation_benchmark", function(value) {}, """ + str(args) + """ ); """) self._micro_benchmark_id = tab.EvaluateJavaScript( 'window.benchmark_results.id') if (not self._micro_benchmark_id): raise page_measurement.MeasurementFailure( 'Failed to schedule invalidation_benchmark.')
def MeasurePage(self, page, tab, results): # Exit if threaded forced compositing is not enabled. if (not self._compositing_features_enabled): logging.warning('Warning: compositing feature status unknown or not '+ 'forced and threaded. Skipping measurement.') sys.exit(0) # Rasterize only what's visible. tab.ExecuteJavaScript( 'chrome.gpuBenchmarking.setRasterizeOnlyVisibleContent();') # Wait until the page has loaded and come to a somewhat steady state. # Needs to be adjusted for every device (~2 seconds for workstation). time.sleep(float(self.options.start_wait_time)) # Render one frame before we start gathering a trace. On some pages, the # first frame requested has more variance in the number of pixels # rasterized. tab.ExecuteJavaScript( 'window.__rafFired = false;' 'window.webkitRequestAnimationFrame(function() {' 'chrome.gpuBenchmarking.setNeedsDisplayOnAllLayers();' 'window.__rafFired = true;' '});') time.sleep(float(self.options.stop_wait_time)) tab.browser.StartTracing('webkit.console,benchmark', 60) tab.ExecuteJavaScript( 'window.__rafFired = false;' 'window.webkitRequestAnimationFrame(function() {' 'chrome.gpuBenchmarking.setNeedsDisplayOnAllLayers();' 'console.time("' + TIMELINE_MARKER + '");' 'window.__rafFired = true;' '});') # Wait until the frame was drawn. # Needs to be adjusted for every device and for different # raster_record_repeat counts. # TODO(ernstm): replace by call-back. time.sleep(float(self.options.stop_wait_time)) tab.ExecuteJavaScript( 'console.timeEnd("' + TIMELINE_MARKER + '")') timeline = tab.browser.StopTracing().AsTimelineModel() try: timeline_markers = timeline.FindTimelineMarkers(TIMELINE_MARKER) except (MarkerMismatchError, MarkerOverlapError) as e: raise page_measurement.MeasurementFailure(str(e)) renderer_process = timeline.GetRendererProcessFromTab(tab) stats = rendering_stats.RenderingStats(renderer_process, timeline_markers) results.Add('rasterize_time', 'ms', max(stats.rasterize_time)) results.Add('record_time', 'ms', max(stats.record_time)) results.Add('rasterized_pixels', 'pixels', max(stats.rasterized_pixel_count)) results.Add('recorded_pixels', 'pixels', max(stats.recorded_pixel_count))
def Stop(self, page, tab): tab.ExecuteJavaScript('console.timeEnd("' + TIMELINE_MARKER + '")') timeline_model = tab.browser.StopTracing().AsTimelineModel() try: timeline_markers = timeline_model.FindTimelineMarkers( self._timeline_marker_names) except MarkerMismatchError as e: raise page_measurement.MeasurementFailure(str(e)) except MarkerOverlapError as e: raise page_measurement.MeasurementFailure(str(e)) renderer_process = timeline_model.GetRendererProcessFromTab(tab) self._stats = rendering_stats.RenderingStats(renderer_process, timeline_markers) if not self._stats.frame_times: raise NotEnoughFramesError()
def MeasurePage(self, page, tab, results): # TODO(vmpstr): Remove this temporary workaround when reference build has # been updated to branch 1713 or later. backend = tab.browser._browser_backend # pylint: disable=W0212 if (not hasattr(backend, 'chrome_branch_number') or (sys.platform != 'android' and backend.chrome_branch_number < 1713)): print( 'Warning: rasterize_and_record_micro requires Chrome branch 1713 ' 'or later. Skipping measurement.') sys.exit(0) try: tab.WaitForJavaScriptExpression( "document.readyState == 'complete'", 10) except TimeoutException: pass time.sleep(float(self.options.start_wait_time)) record_repeat = self.options.record_repeat rasterize_repeat = self.options.rasterize_repeat # Enqueue benchmark tab.ExecuteJavaScript(""" window.benchmark_results = {}; window.benchmark_results.done = false; window.benchmark_results.scheduled = chrome.gpuBenchmarking.runMicroBenchmark( "rasterize_and_record_benchmark", function(value) { window.benchmark_results.done = true; window.benchmark_results.results = value; }, { "record_repeat_count": """ + str(record_repeat) + """, "rasterize_repeat_count": """ + str(rasterize_repeat) + """ }); """) scheduled = tab.EvaluateJavaScript( 'window.benchmark_results.scheduled') if (not scheduled): raise page_measurement.MeasurementFailure( 'Failed to schedule rasterize_and_record_micro') tab.WaitForJavaScriptExpression('window.benchmark_results.done', self.options.timeout) data = tab.EvaluateJavaScript('window.benchmark_results.results') pixels_recorded = data['pixels_recorded'] record_time = data['record_time_ms'] pixels_rasterized = data['pixels_rasterized'] rasterize_time = data['rasterize_time_ms'] results.Add('pixels_recorded', '', pixels_recorded) results.Add('record_time', 'ms', record_time) results.Add('pixels_rasterized', '', pixels_rasterized) results.Add('rasterize_time', 'ms', rasterize_time)
def MeasurePage(self, page, tab, results): if tab.browser.platform.GetOSName() in ['android', 'chromeos']: raise page_measurement.MeasurementFailure( 'SkPicture printing not supported on this platform') # Replace win32 path separator char '\' with '\\'. outpath = os.path.abspath( os.path.join(self._skp_outdir, page.file_safe_name)) js = _JS.format(outpath.replace('\\', '\\\\')) tab.EvaluateJavaScript(js) pictures = glob.glob(os.path.join(outpath, '*.skp')) results.Add('saved_picture_count', 'count', len(pictures))
def Stop(self, page, tab): tab.ExecuteJavaScript('console.timeEnd("' + TIMELINE_MARKER + '")') timeline_model = tab.browser.StopTracing().AsTimelineModel() render_process_marker = timeline_model.FindTimelineMarkers(TIMELINE_MARKER) timeline_marker_labels = GetTimelineMarkerLabelsFromAction( self._compound_action) try: timeline_markers = timeline_model.FindTimelineMarkers( timeline_marker_labels) except MarkerMismatchError: # TODO(ernstm): re-raise exception as MeasurementFailure when the # reference build was updated. timeline_markers = render_process_marker except MarkerOverlapError as e: raise page_measurement.MeasurementFailure(str(e)) self._stats = rendering_stats.RenderingStats( render_process_marker, timeline_markers) if not self._stats.frame_times: raise NotEnoughFramesError()
def MeasurePage(self, page, tab, results): try: tab.WaitForJavaScriptExpression( "document.readyState == 'complete'", 10) except TimeoutException: pass time.sleep(self.options.start_wait_time) record_repeat = self.options.record_repeat rasterize_repeat = self.options.rasterize_repeat # Enqueue benchmark tab.ExecuteJavaScript(""" window.benchmark_results = {}; window.benchmark_results.done = false; window.benchmark_results.scheduled = chrome.gpuBenchmarking.runMicroBenchmark( "rasterize_and_record_benchmark", function(value) { window.benchmark_results.done = true; window.benchmark_results.results = value; }, { "record_repeat_count": """ + str(record_repeat) + """, "rasterize_repeat_count": """ + str(rasterize_repeat) + """ }); """) scheduled = tab.EvaluateJavaScript( 'window.benchmark_results.scheduled') if (not scheduled): raise page_measurement.MeasurementFailure( 'Failed to schedule rasterize_and_record_micro') tab.WaitForJavaScriptExpression('window.benchmark_results.done', self.options.timeout) data = tab.EvaluateJavaScript('window.benchmark_results.results') pixels_recorded = data['pixels_recorded'] record_time = data['record_time_ms'] pixels_rasterized = data['pixels_rasterized'] rasterize_time = data['rasterize_time_ms'] results.Add('pixels_recorded', 'pixels', pixels_recorded) results.Add('record_time', 'ms', record_time) results.Add('pixels_rasterized', 'pixels', pixels_rasterized) results.Add('rasterize_time', 'ms', rasterize_time) # TODO(skyostil): Remove this temporary workaround when reference build has # been updated to branch 1931 or later. if ((self._chrome_branch_number and self._chrome_branch_number >= 1931) or sys.platform == 'android'): record_time_sk_null_canvas = data['record_time_sk_null_canvas_ms'] record_time_painting_disabled = data[ 'record_time_painting_disabled_ms'] record_time_skrecord = data['record_time_skrecord_ms'] results.Add('record_time_sk_null_canvas', 'ms', record_time_sk_null_canvas) results.Add('record_time_painting_disabled', 'ms', record_time_painting_disabled) results.Add('record_time_skrecord', 'ms', record_time_skrecord) if self.options.report_detailed_results: pixels_rasterized_with_non_solid_color = \ data['pixels_rasterized_with_non_solid_color'] pixels_rasterized_as_opaque = \ data['pixels_rasterized_as_opaque'] total_layers = data['total_layers'] total_picture_layers = data['total_picture_layers'] total_picture_layers_with_no_content = \ data['total_picture_layers_with_no_content'] total_picture_layers_off_screen = \ data['total_picture_layers_off_screen'] results.Add('pixels_rasterized_with_non_solid_color', 'pixels', pixels_rasterized_with_non_solid_color) results.Add('pixels_rasterized_as_opaque', 'pixels', pixels_rasterized_as_opaque) results.Add('total_layers', 'count', total_layers) results.Add('total_picture_layers', 'count', total_picture_layers) results.Add('total_picture_layers_with_no_content', 'count', total_picture_layers_with_no_content) results.Add('total_picture_layers_off_screen', 'count', total_picture_layers_off_screen)
def MeasurePage(self, page, tab, results): if not self._compositing_features_enabled: raise page_test.TestNotSupportedOnPlatformFailure( 'Compositing feature status unknown or not ' + 'forced and threaded. Skipping measurement.') try: tab.WaitForJavaScriptExpression( "document.readyState == 'complete'", 10) except TimeoutException: pass time.sleep(self.options.start_wait_time) record_repeat = self.options.record_repeat rasterize_repeat = self.options.rasterize_repeat # Enqueue benchmark tab.ExecuteJavaScript(""" window.benchmark_results = {}; window.benchmark_results.done = false; window.benchmark_results.scheduled = chrome.gpuBenchmarking.runMicroBenchmark( "rasterize_and_record_benchmark", function(value) { window.benchmark_results.done = true; window.benchmark_results.results = value; }, { "record_repeat_count": """ + str(record_repeat) + """, "rasterize_repeat_count": """ + str(rasterize_repeat) + """ }); """) scheduled = tab.EvaluateJavaScript( 'window.benchmark_results.scheduled') if (not scheduled): raise page_measurement.MeasurementFailure( 'Failed to schedule rasterize_and_record_micro') tab.WaitForJavaScriptExpression('window.benchmark_results.done', self.options.timeout) data = tab.EvaluateJavaScript('window.benchmark_results.results') pixels_recorded = data['pixels_recorded'] record_time = data['record_time_ms'] record_time_sk_null_canvas = data['record_time_sk_null_canvas_ms'] record_time_painting_disabled = data[ 'record_time_painting_disabled_ms'] pixels_rasterized = data['pixels_rasterized'] rasterize_time = data['rasterize_time_ms'] results.Add('pixels_recorded', 'pixels', pixels_recorded) results.Add('record_time', 'ms', record_time) results.Add('record_time_sk_null_canvas', 'ms', record_time_sk_null_canvas) results.Add('record_time_painting_disabled', 'ms', record_time_painting_disabled) results.Add('pixels_rasterized', 'pixels', pixels_rasterized) results.Add('rasterize_time', 'ms', rasterize_time) if self.options.report_detailed_results: pixels_rasterized_with_non_solid_color = \ data['pixels_rasterized_with_non_solid_color'] pixels_rasterized_as_opaque = \ data['pixels_rasterized_as_opaque'] total_layers = data['total_layers'] total_picture_layers = data['total_picture_layers'] total_picture_layers_with_no_content = \ data['total_picture_layers_with_no_content'] total_picture_layers_off_screen = \ data['total_picture_layers_off_screen'] results.Add('pixels_rasterized_with_non_solid_color', 'pixels', pixels_rasterized_with_non_solid_color) results.Add('pixels_rasterized_as_opaque', 'pixels', pixels_rasterized_as_opaque) results.Add('total_layers', 'count', total_layers) results.Add('total_picture_layers', 'count', total_picture_layers) results.Add('total_picture_layers_with_no_content', 'count', total_picture_layers_with_no_content) results.Add('total_picture_layers_off_screen', 'count', total_picture_layers_off_screen)
def MeasurePage(self, page, tab, results): if not self._compositing_features_enabled: logging.warning('Warning: RasterizeAndRecordMicro requires forced, ' 'threaded compositing and Chrome branch 1713 or newer.') return try: tab.WaitForJavaScriptExpression("document.readyState == 'complete'", 10) except TimeoutException: pass time.sleep(self.options.start_wait_time) record_repeat = self.options.record_repeat rasterize_repeat = self.options.rasterize_repeat # Enqueue benchmark tab.ExecuteJavaScript(""" window.benchmark_results = {}; window.benchmark_results.done = false; window.benchmark_results.scheduled = chrome.gpuBenchmarking.runMicroBenchmark( "rasterize_and_record_benchmark", function(value) { window.benchmark_results.done = true; window.benchmark_results.results = value; }, { "record_repeat_count": """ + str(record_repeat) + """, "rasterize_repeat_count": """ + str(rasterize_repeat) + """ }); """) scheduled = tab.EvaluateJavaScript('window.benchmark_results.scheduled') if (not scheduled): raise page_measurement.MeasurementFailure( 'Failed to schedule rasterize_and_record_micro') tab.WaitForJavaScriptExpression( 'window.benchmark_results.done', self.options.timeout) data = tab.EvaluateJavaScript('window.benchmark_results.results') pixels_recorded = data['pixels_recorded'] record_time = data['record_time_ms'] pixels_rasterized = data['pixels_rasterized'] rasterize_time = data['rasterize_time_ms'] results.Add('pixels_recorded', 'pixels', pixels_recorded) results.Add('record_time', 'ms', record_time) results.Add('pixels_rasterized', 'pixels', pixels_rasterized) results.Add('rasterize_time', 'ms', rasterize_time) if self.options.report_detailed_results: pixels_rasterized_with_non_solid_color = \ data['pixels_rasterized_with_non_solid_color'] pixels_rasterized_as_opaque = \ data['pixels_rasterized_as_opaque'] total_layers = data['total_layers'] total_picture_layers = data['total_picture_layers'] total_picture_layers_with_no_content = \ data['total_picture_layers_with_no_content'] total_picture_layers_off_screen = \ data['total_picture_layers_off_screen'] results.Add('pixels_rasterized_with_non_solid_color', 'pixels', pixels_rasterized_with_non_solid_color) results.Add('pixels_rasterized_as_opaque', 'pixels', pixels_rasterized_as_opaque) results.Add('total_layers', 'count', total_layers) results.Add('total_picture_layers', 'count', total_picture_layers) results.Add('total_picture_layers_with_no_content', 'count', total_picture_layers_with_no_content) results.Add('total_picture_layers_off_screen', 'count', total_picture_layers_off_screen)
def MeasurePage(self, page, tab, results): query = tab.EvaluateJavaScript('window.location.search') expected = '?foo=1' if query.strip() != expected: raise page_measurement.MeasurementFailure('query was %s, not %s.' % (query, expected))
def MeasurePage(self, page, tab, results): # Web Page Replay returns '404 Not found' if a page is not in the archive. contents = tab.EvaluateJavaScript('document.body.textContent') if '404 Not Found' in contents.strip(): raise page_measurement.MeasurementFailure('Page not in archive.')
def MeasurePage(self, page, tab, results): contents = tab.EvaluateJavaScript('document.body.textContent') if contents.strip() != 'Hello world': raise page_measurement.MeasurementFailure('Page contents were: ' + contents)
def MeasurePage(self, page, tab, results): raise page_measurement.MeasurementFailure('Intentional failure.')
def MeasurePage(self, page, tab, results): # Exit if threaded forced compositing is not enabled. if (not self._compositing_features_enabled): logging.warning('Warning: compositing feature status unknown or not '+ 'forced and threaded. Skipping measurement.') sys.exit(0) # TODO(ernstm): Remove this temporary workaround when reference build has # been updated to branch 1671 or later. backend = tab.browser._browser_backend # pylint: disable=W0212 if (not hasattr(backend, 'chrome_branch_number') or (sys.platform != 'android' and backend.chrome_branch_number < 1671)): print ('Warning: rasterize_and_record requires Chrome branch 1671 or ' 'later. Skipping measurement.') sys.exit(0) # Rasterize only what's visible. tab.ExecuteJavaScript( 'chrome.gpuBenchmarking.setRasterizeOnlyVisibleContent();') # Wait until the page has loaded and come to a somewhat steady state. # Needs to be adjusted for every device (~2 seconds for workstation). time.sleep(float(self.options.start_wait_time)) # Render one frame before we start gathering a trace. On some pages, the # first frame requested has more variance in the number of pixels # rasterized. tab.ExecuteJavaScript( 'window.__rafFired = false;' 'window.webkitRequestAnimationFrame(function() {' 'chrome.gpuBenchmarking.setNeedsDisplayOnAllLayers();' 'window.__rafFired = true;' '});') time.sleep(float(self.options.stop_wait_time)) tab.browser.StartTracing('webkit.console,benchmark', 60) tab.ExecuteJavaScript( 'window.__rafFired = false;' 'window.webkitRequestAnimationFrame(function() {' 'chrome.gpuBenchmarking.setNeedsDisplayOnAllLayers();' 'console.time("' + rendering_stats.RENDER_PROCESS_MARKER + '");' 'window.__rafFired = true;' '});') # Wait until the frame was drawn. # Needs to be adjusted for every device and for different # raster_record_repeat counts. # TODO(ernstm): replace by call-back. time.sleep(float(self.options.stop_wait_time)) tab.ExecuteJavaScript( 'console.timeEnd("' + rendering_stats.RENDER_PROCESS_MARKER + '")') timeline = tab.browser.StopTracing().AsTimelineModel() try: timeline_markers = timeline.FindTimelineMarkers( rendering_stats.RENDER_PROCESS_MARKER) except (MarkerMismatchError, MarkerOverlapError) as e: raise page_measurement.MeasurementFailure(str(e)) stats = rendering_stats.RenderingStats(timeline_markers, timeline_markers) results.Add('rasterize_time', 'ms', max(stats.rasterize_time)) results.Add('record_time', 'ms', max(stats.record_time)) results.Add('rasterized_pixels', 'pixels', max(stats.rasterized_pixel_count)) results.Add('recorded_pixels', 'pixels', max(stats.recorded_pixel_count))