def ValidateAndMeasurePage(self, page, tab, results):
if not hasattr(self.options, 'x'):
raise page_test.MeasurementFailure('Default option was not set.')
if self.options.x != 3:
raise page_test.MeasurementFailure('Expected x == 3, got x == ' +
self.options.x)
results.AddValue(scalar.ScalarValue(page, 'x', 'ms', 7))
def ValidateAndMeasurePage(self, page, tab, results):
# Wait for the load event.
tab.WaitForJavaScriptExpression('performance.timing.loadEventStart',
300)
self._metrics.Stop(page, tab)
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],
}
if not page.name in page_to_metrics:
raise page_test.MeasurementFailure(
'Invalid page name (%s) in QUIC smoke. '
'Page name must be one of:\n%s' %
(page.name, page_to_metrics.keys()))
for add_result in page_to_metrics[page.name]:
add_result(tab, results)
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_test.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.SetUp(page, tab)
self._smoothness_controller.Start(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_test.MeasurementFailure(
'Failed to schedule invalidation_benchmark.')
def ValidateAndMeasurePage(self, page, tab, results):
if tab.browser.platform.GetOSName() in ['android', 'chromeos']:
raise page_test.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.AddValue(scalar.ScalarValue(
results.current_page, 'saved_picture_count', 'count', len(pictures)))
def Repaint(action_runner, mode='viewport', width=None, height=None):
action_runner.WaitForJavaScriptCondition(
'document.readyState == "complete"', 90)
# Rasterize only what's visible.
action_runner.ExecuteJavaScript(
'chrome.gpuBenchmarking.setRasterizeOnlyVisibleContent();')
args = {}
args['mode'] = mode
if width:
args['width'] = width
if height:
args['height'] = height
# Enqueue benchmark
action_runner.ExecuteJavaScript("""
window.benchmark_results = {};
window.benchmark_results.id =
chrome.gpuBenchmarking.runMicroBenchmark(
"invalidation_benchmark",
function(value) {},
""" + str(args) + """
);
""")
micro_benchmark_id = action_runner.EvaluateJavaScript(
'window.benchmark_results.id')
if not micro_benchmark_id:
raise page_test.MeasurementFailure(
'Failed to schedule invalidation_benchmark.')
with action_runner.CreateInteraction('Repaint'):
action_runner.RepaintContinuously(seconds=5)
action_runner.ExecuteJavaScript("""
window.benchmark_results.message_handled =
chrome.gpuBenchmarking.sendMessageToMicroBenchmark(
""" + str(micro_benchmark_id) + """, {
"notify_done": true
});
""")
def ValidateAndMeasurePage(self, page, tab, results):
query = tab.EvaluateJavaScript('window.location.search')
expected = '?foo=1'
if query.strip() != expected:
raise page_test.MeasurementFailure('query was %s, not %s.' %
(query, expected))
def ValidateAndMeasurePage(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_test.MeasurementFailure('Page not in archive.')
def ValidateAndMeasurePage(self, page, tab, results):
contents = tab.EvaluateJavaScript('document.body.textContent')
if contents.strip() != 'Hello world':
raise page_test.MeasurementFailure('Page contents were: ' +
contents)
def ValidateAndMeasurePage(self, page, tab, results):
try:
tab.WaitForDocumentReadyStateToBeComplete()
except TimeoutException:
pass
time.sleep(self._start_wait_time)
# Enqueue benchmark
tab.ExecuteJavaScript("""
window.benchmark_results = {};
window.benchmark_results.done = false;
window.benchmark_results.id =
chrome.gpuBenchmarking.runMicroBenchmark(
"rasterize_and_record_benchmark",
function(value) {
window.benchmark_results.done = true;
window.benchmark_results.results = value;
}, {
"record_repeat_count": %i,
"rasterize_repeat_count": %i
});
""" % (self._record_repeat, self._rasterize_repeat))
benchmark_id = tab.EvaluateJavaScript('window.benchmark_results.id')
if (not benchmark_id):
raise page_test.MeasurementFailure(
'Failed to schedule rasterize_and_record_micro')
tab.WaitForJavaScriptExpression(
'window.benchmark_results.done', self._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']
# TODO(schenney): Remove this workaround when reference builds get past
# the change that adds this comment.
if ('picture_memory_usage' in data):
picture_memory_usage = data['picture_memory_usage']
else:
picture_memory_usage = 0
results.AddValue(scalar.ScalarValue(
results.current_page, 'pixels_recorded', 'pixels', pixels_recorded))
results.AddValue(scalar.ScalarValue(
results.current_page, 'pixels_rasterized', 'pixels', pixels_rasterized))
results.AddValue(scalar.ScalarValue(
results.current_page, 'rasterize_time', 'ms', rasterize_time))
results.AddValue(scalar.ScalarValue(
results.current_page, 'viewport_picture_size', 'bytes',
picture_memory_usage))
results.AddValue(scalar.ScalarValue(
results.current_page, 'record_time', 'ms', record_time))
record_time_sk_null_canvas = data['record_time_sk_null_canvas_ms']
record_time_painting_disabled = data['record_time_painting_disabled_ms']
results.AddValue(scalar.ScalarValue(
results.current_page, 'record_time_sk_null_canvas', 'ms',
record_time_sk_null_canvas))
results.AddValue(scalar.ScalarValue(
results.current_page, 'record_time_painting_disabled', 'ms',
record_time_painting_disabled))
if self._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']
# TODO(schenney): Remove this workaround when reference builds get past
# the change that adds this comment.
if ('total_pictures_in_pile_size' in data):
total_pictures_in_pile_size = data['total_pictures_in_pile_size']
else:
total_pictures_in_pile_size = 0
results.AddValue(scalar.ScalarValue(
results.current_page, 'total_size_of_pictures_in_piles', 'bytes',
total_pictures_in_pile_size))
results.AddValue(scalar.ScalarValue(
results.current_page, 'pixels_rasterized_with_non_solid_color',
'pixels', pixels_rasterized_with_non_solid_color))
results.AddValue(scalar.ScalarValue(
results.current_page, 'pixels_rasterized_as_opaque', 'pixels',
pixels_rasterized_as_opaque))
results.AddValue(scalar.ScalarValue(
results.current_page, 'total_layers', 'count', total_layers))
results.AddValue(scalar.ScalarValue(
results.current_page, 'total_picture_layers', 'count',
total_picture_layers))
results.AddValue(scalar.ScalarValue(
results.current_page, 'total_picture_layers_with_no_content', 'count',
total_picture_layers_with_no_content))
results.AddValue(scalar.ScalarValue(
results.current_page, 'total_picture_layers_off_screen', 'count',
total_picture_layers_off_screen))
def ValidateAndMeasurePage(self, page, tab, results):
try:
tab.WaitForDocumentReadyStateToBeComplete()
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.id =
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) + """
});
""")
benchmark_id = tab.EvaluateJavaScript('window.benchmark_results.id')
if (not benchmark_id):
raise page_test.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.AddValue(
scalar.ScalarValue(results.current_page, 'pixels_recorded',
'pixels', pixels_recorded))
results.AddValue(
scalar.ScalarValue(results.current_page, 'record_time', 'ms',
record_time))
results.AddValue(
scalar.ScalarValue(results.current_page, 'pixels_rasterized',
'pixels', pixels_rasterized))
results.AddValue(
scalar.ScalarValue(results.current_page, '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.AddValue(
scalar.ScalarValue(results.current_page,
'record_time_sk_null_canvas', 'ms',
record_time_sk_null_canvas))
results.AddValue(
scalar.ScalarValue(results.current_page,
'record_time_painting_disabled', 'ms',
record_time_painting_disabled))
results.AddValue(
scalar.ScalarValue(results.current_page,
'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.AddValue(
scalar.ScalarValue(results.current_page,
'pixels_rasterized_with_non_solid_color',
'pixels',
pixels_rasterized_with_non_solid_color))
results.AddValue(
scalar.ScalarValue(results.current_page,
'pixels_rasterized_as_opaque', 'pixels',
pixels_rasterized_as_opaque))
results.AddValue(
scalar.ScalarValue(results.current_page, 'total_layers',
'count', total_layers))
results.AddValue(
scalar.ScalarValue(results.current_page,
'total_picture_layers', 'count',
total_picture_layers))
results.AddValue(
scalar.ScalarValue(results.current_page,
'total_picture_layers_with_no_content',
'count',
total_picture_layers_with_no_content))
results.AddValue(
scalar.ScalarValue(results.current_page,
'total_picture_layers_off_screen', 'count',
total_picture_layers_off_screen))
