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))