fenced-frame/background-sync.https.html - external/github.com/web-platform-tests/wpt - Git at Google

 <!DOCTYPE html>
 <title>Test fenced frame does not allow to register background sync</title>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="resources/utils.js"></script>
 <script src="/common/get-host-info.sub.js"></script>
 <script src="/common/utils.js"></script>
 <body>
 <script>
 const background_sync_register_key = token();
 const fenced_frame_url = 'resources/background-sync-inner.https.html';
 const fenced_frame_url_for_service_worker_test =
   'resources/background-sync-sw-inner.https.html';

 const generateFencedFrameUrl = (params, is_worker_test = false) => {
   const searchParams = new URLSearchParams(params);
   const frame_url = is_worker_test ?
     fenced_frame_url_for_service_worker_test : fenced_frame_url;

   return generateURL(`${frame_url}?${searchParams.toString()}`,
     [background_sync_register_key]);
 };

 async function background_sync_test(url, expected_text, message) {
   attachFencedFrame(url)

   // Get the result for the top-level fenced frame.
   const fenced_frame_result =
       await nextValueFromServer(background_sync_register_key);
   assert_equals(fenced_frame_result, expected_text, message);
 };

 const background_sync_message =
   "Background Sync is not allowed in fenced frames.";
 const periodic_background_sync_message =
   "Periodic Background Sync is not allowed in fenced frames.";

 promise_test(async (t) => {
   const method = 'register';
   const frame_url = generateFencedFrameUrl({method});
   const expected_message = "Failed to execute 'register' on 'SyncManager': " +
     background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'register() is disallowed inside a same-origin fenced frame');

   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'register() is disallowed inside a cross-origin fenced frame');
 }, 'background sync register');

 promise_test(async (t) => {
   const method = 'getTags';
   const frame_url = generateFencedFrameUrl({method});
   const expected_message = background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'getTags() is disallowed inside a same-origin fenced frame');

   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'getTags() is disallowed inside a cross-origin fenced frame');
 }, 'background sync getTags');

 promise_test(async (t) => {
   const method = 'register';
   const frame_url = generateFencedFrameUrl({method}, true);
   const expected_message = "Failed to execute 'register' on 'SyncManager': " +
     background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'register() is disallowed inside a same-origin fenced frame');
   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'register() is disallowed inside a cross-origin fenced frame');
 }, 'background sync register in service worker');

 promise_test(async (t) => {
   const method = 'getTags';
   const frame_url = generateFencedFrameUrl({method}, true);
   const expected_message = background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'getTags() is disallowed inside a same-origin fenced frame');
   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'getTags() is disallowed inside a cross-origin fenced frame');
 }, 'background sync getTags in service worker');

 promise_test(async (t) => {
   const params = {
     method: 'register',
     periodic: true
   };
   const frame_url = generateFencedFrameUrl(params)
   const expected_message = "Failed to execute 'register' on " +
     "'PeriodicSyncManager': " + periodic_background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'register() is disallowed inside a same-origin fenced frame');

   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'register() is disallowed inside a cross-origin fenced frame');
 }, 'periodic sync register');

 promise_test(async (t) => {
   const params = {
     method: 'getTags',
     periodic: true
   };
   const frame_url = generateFencedFrameUrl(params)
   const expected_message = periodic_background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'getTags() is disallowed inside a same-origin fenced frame');

   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'getTags() is disallowed inside a cross-origin fenced frame');
 }, 'periodic sync getTags');

 promise_test(async (t) => {
   const params = {
     method: 'unregister',
     periodic: true
   };
   const frame_url = generateFencedFrameUrl(params)
   const expected_message = periodic_background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'unregister() is disallowed inside a same-origin fenced frame');

   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'unregister() is disallowed inside a cross-origin fenced frame');
 }, 'periodic sync unregister');

 promise_test(async (t) => {
   const params = {
     method: 'register',
     periodic: true
   };
   const frame_url = generateFencedFrameUrl(params, true)
   const expected_message = "Failed to execute 'register' on " +
     "'PeriodicSyncManager': " + periodic_background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'register() is disallowed inside a same-origin fenced frame');

   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'register() is disallowed inside a cross-origin fenced frame');
 }, 'periodic sync register in service worker');

 promise_test(async (t) => {
   const params = {
     method: 'getTags',
     periodic: true
   };
   const frame_url = generateFencedFrameUrl(params, true)
   const expected_message = periodic_background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'getTags() is disallowed inside a same-origin fenced frame');

   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'getTags() is disallowed inside a cross-origin fenced frame');
 }, 'periodic sync getTags in service worker');

 promise_test(async (t) => {
   const params = {
     method: 'unregister',
     periodic: true
   };
   const frame_url = generateFencedFrameUrl(params, true)
   const expected_message = periodic_background_sync_message;
   await background_sync_test(
       frame_url,
       expected_message,
       'unregister() is disallowed inside a same-origin fenced frame');

   const cross_origin_frame_url = getRemoteOriginURL(frame_url);
   await background_sync_test(
       cross_origin_frame_url,
       expected_message,
       'unregister() is disallowed inside a cross-origin fenced frame');
 }, 'periodic sync unregister in service worker');
 </script>
 </body>
	<!DOCTYPE html>
	<title>Test fenced frame does not allow to register background sync</title>
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="resources/utils.js"></script>
	<script src="/common/get-host-info.sub.js"></script>
	<script src="/common/utils.js"></script>
	<body>
	<script>
	const background_sync_register_key = token();
	const fenced_frame_url = 'resources/background-sync-inner.https.html';
	const fenced_frame_url_for_service_worker_test =
	'resources/background-sync-sw-inner.https.html';

	const generateFencedFrameUrl = (params, is_worker_test = false) => {
	const searchParams = new URLSearchParams(params);
	const frame_url = is_worker_test ?
	fenced_frame_url_for_service_worker_test : fenced_frame_url;

	return generateURL(`${frame_url}?${searchParams.toString()}`,
	[background_sync_register_key]);
	};

	async function background_sync_test(url, expected_text, message) {
	attachFencedFrame(url)

	// Get the result for the top-level fenced frame.
	const fenced_frame_result =
	await nextValueFromServer(background_sync_register_key);
	assert_equals(fenced_frame_result, expected_text, message);
	};

	const background_sync_message =
	"Background Sync is not allowed in fenced frames.";
	const periodic_background_sync_message =
	"Periodic Background Sync is not allowed in fenced frames.";

	promise_test(async (t) => {
	const method = 'register';
	const frame_url = generateFencedFrameUrl({method});
	const expected_message = "Failed to execute 'register' on 'SyncManager': " +
	background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'register() is disallowed inside a same-origin fenced frame');

	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'register() is disallowed inside a cross-origin fenced frame');
	}, 'background sync register');

	promise_test(async (t) => {
	const method = 'getTags';
	const frame_url = generateFencedFrameUrl({method});
	const expected_message = background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'getTags() is disallowed inside a same-origin fenced frame');

	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'getTags() is disallowed inside a cross-origin fenced frame');
	}, 'background sync getTags');

	promise_test(async (t) => {
	const method = 'register';
	const frame_url = generateFencedFrameUrl({method}, true);
	const expected_message = "Failed to execute 'register' on 'SyncManager': " +
	background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'register() is disallowed inside a same-origin fenced frame');
	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'register() is disallowed inside a cross-origin fenced frame');
	}, 'background sync register in service worker');

	promise_test(async (t) => {
	const method = 'getTags';
	const frame_url = generateFencedFrameUrl({method}, true);
	const expected_message = background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'getTags() is disallowed inside a same-origin fenced frame');
	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'getTags() is disallowed inside a cross-origin fenced frame');
	}, 'background sync getTags in service worker');

	promise_test(async (t) => {
	const params = {
	method: 'register',
	periodic: true
	};
	const frame_url = generateFencedFrameUrl(params)
	const expected_message = "Failed to execute 'register' on " +
	"'PeriodicSyncManager': " + periodic_background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'register() is disallowed inside a same-origin fenced frame');

	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'register() is disallowed inside a cross-origin fenced frame');
	}, 'periodic sync register');

	promise_test(async (t) => {
	const params = {
	method: 'getTags',
	periodic: true
	};
	const frame_url = generateFencedFrameUrl(params)
	const expected_message = periodic_background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'getTags() is disallowed inside a same-origin fenced frame');

	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'getTags() is disallowed inside a cross-origin fenced frame');
	}, 'periodic sync getTags');

	promise_test(async (t) => {
	const params = {
	method: 'unregister',
	periodic: true
	};
	const frame_url = generateFencedFrameUrl(params)
	const expected_message = periodic_background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'unregister() is disallowed inside a same-origin fenced frame');

	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'unregister() is disallowed inside a cross-origin fenced frame');
	}, 'periodic sync unregister');

	promise_test(async (t) => {
	const params = {
	method: 'register',
	periodic: true
	};
	const frame_url = generateFencedFrameUrl(params, true)
	const expected_message = "Failed to execute 'register' on " +
	"'PeriodicSyncManager': " + periodic_background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'register() is disallowed inside a same-origin fenced frame');

	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'register() is disallowed inside a cross-origin fenced frame');
	}, 'periodic sync register in service worker');

	promise_test(async (t) => {
	const params = {
	method: 'getTags',
	periodic: true
	};
	const frame_url = generateFencedFrameUrl(params, true)
	const expected_message = periodic_background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'getTags() is disallowed inside a same-origin fenced frame');

	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'getTags() is disallowed inside a cross-origin fenced frame');
	}, 'periodic sync getTags in service worker');

	promise_test(async (t) => {
	const params = {
	method: 'unregister',
	periodic: true
	};
	const frame_url = generateFencedFrameUrl(params, true)
	const expected_message = periodic_background_sync_message;
	await background_sync_test(
	frame_url,
	expected_message,
	'unregister() is disallowed inside a same-origin fenced frame');

	const cross_origin_frame_url = getRemoteOriginURL(frame_url);
	await background_sync_test(
	cross_origin_frame_url,
	expected_message,
	'unregister() is disallowed inside a cross-origin fenced frame');
	}, 'periodic sync unregister in service worker');
	</script>
	</body>