chromium/src/third_party/blink/web_tests/wpt_internal/cache_storage/padding.https.html - manifest_repos/chromium_src - Git at Google

 <!doctype html>
 <title>Cache Storage: verify cache_storage padding behavior</title>
 <link rel="help" href="https://w3c.github.io/ServiceWorker/#cache-interface">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/common/get-host-info.sub.js"></script>
 <script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
 <script>
 'use strict';

 const tmp_url = new URL('resources/simple.js', self.location);
 tmp_url.hostname = get_host_info().REMOTE_HOST;
 const TARGET_URL = tmp_url.href;

 async function usage(init) {
   const cache = await caches.open('padding');
   if (!init.mode)
     init.mode = 'no-cors';
   let r = await fetch(TARGET_URL, init);
   if (init.mode == 'no-cors')
     assert_equals(r.type, 'opaque');
   const clone = r.clone();
   // Note, this stores the response under a Request key that has a different
   // url than what we fetched above.  This is purposeful to ensure
   // that we are varying on how the Response was loaded and not on the Request
   // key.
   const cache_url = '/foo';
   await cache.put(cache_url, r);
   const usage1 = (await navigator.storage.estimate()).usageDetails.caches;
   await cache.delete(cache_url);

   await cache.put(cache_url, clone);
   const usage2 = (await navigator.storage.estimate()).usageDetails.caches;
   await cache.delete(cache_url);

   assert_equals(usage1, usage2, 'cloned response have the same padding size');
   return usage1;
 }

 promise_test(async t => {
   const usage1 = await usage({ cache: 'reload' });
   const usage2 = await usage({ cache: 'reload' });
   assert_not_equals(usage1, usage2,
                     'Responses loaded from network should have different ' +
                     'padding size.');
 }, 'Cache padding varies if loaded from network.');

 promise_test(async t => {
   // populate http cache
   await usage({ cache: 'reload' });

   const cache_usage1 = await usage({ cache: 'force-cache' });
   const cache_usage2 = await usage({ cache: 'force-cache' });

   assert_equals(cache_usage1, cache_usage2,
                 'Responses loaded from http cache should have the same ' +
                 'padding size.');

   // repopulate http cache
   await usage({ cache: 'reload' });

   const cache_usage3 = await usage({ cache: 'force-cache' });
   const cache_usage4 = await usage({ cache: 'force-cache' });

   assert_not_equals(cache_usage1, cache_usage3,
                     'An updated http cache entry should result in a ' +
                     'different padding size.');
   assert_equals(cache_usage3, cache_usage4,
                 'Responses loaded from http cache should have the same ' +
                 'padding size.');
 }, 'Cache padding is stable if loaded from http cache.');

 promise_test(async t => {
   // Determine the actual size difference between GET and HEAD requests.
   const cors_get_usage = await usage({ mode: 'cors', method: 'GET' });
   const cors_head_usage = await usage({ mode: 'cors', method: 'HEAD' });
   const cors_diff = cors_get_usage - cors_head_usage;

   const net_get_usage = await usage({ method: 'GET', cache: 'reload' });
   const net_head_usage = await usage({ method: 'HEAD', cache: 'reload' });
   const opaque_net_diff = net_get_usage - net_head_usage;

   assert_not_equals(net_get_usage, net_head_usage,
                     'Responses loaded from network with different methods ' +
                     'should have different padding size.');
   assert_not_equals(opaque_net_diff, cors_diff,
                     'Responses loaded from network with different methods ' +
                     'should have usages that differ more than actual ' +
                     'response size.');

   // populate http cache
   await usage({ cache: 'reload' });

   const cache_get_usage = await usage({ method: 'GET', cache: 'force-cache' });
   const cache_head_usage = await usage({ method: 'HEAD', cache: 'force-cache' });
   const opaque_cache_diff = cache_get_usage - cache_head_usage;

   assert_not_equals(cache_get_usage, cache_head_usage,
                     'Responses loaded from http cache with different methods ' +
                     'should have the different padding size.');
   assert_not_equals(opaque_cache_diff, cors_diff,
                     'Responses loaded from http cache with different methods ' +
                     'should have usages that differ more than actual ' +
                     'response size.');
 }, 'Cache padding varies with request method.');

 promise_test(async t => {
   const cache1 = await caches.open('padding');
   const cache2 = await caches.open('padding-2');

   const net_response = await fetch(TARGET_URL, { mode: 'no-cors',
                                                  cache: 'reload' });
   await cache1.put(TARGET_URL, net_response);
   const usage1 = (await navigator.storage.estimate()).usageDetails.caches;

   const cache_response = await cache1.match(TARGET_URL);
   await cache2.put(TARGET_URL, cache_response);
   await cache1.delete(TARGET_URL);
   const usage2 = (await navigator.storage.estimate()).usageDetails.caches;
   await cache2.delete(TARGET_URL);

   assert_equals(usage1, usage2,
                 'The padding value should follow a response loaded from ' +
                 'cache_storage.');

 }, 'Cache padding follows a response loaded from cache_storage.');

 promise_test(async t => {
   const script = './resources/padding-fetch-sw.js';
   const scope = './resources/padding-fetch-frame.html';

   // Setup a service worker.
   const reg = await service_worker_unregister_and_register(t, script, scope);
   t.add_cleanup(() => reg.unregister());
   await wait_for_state(t, reg.installing, 'activated');

   // Setup an iframe controlled by the service worker.
   const frame = await with_iframe(scope);
   t.add_cleanup(() => frame.remove());

   // The service worker will send a padded usage value via postMessage.
   // Prepare to receive this message.
   const message_promise = new Promise(resolve => {
     frame.contentWindow.navigator.serviceWorker.addEventListener('message',
         evt => {
           if (!('usage' in evt.data))
             return;
           resolve(evt.data.usage);
         });
   });

   // Fetch an opaque response from the network.  This will hit the
   // service worker fetch handler which will compute a padded usage
   // value before allowing this outer fetch to resolve.  The SW
   // usage value is sent via an out-of-band postMessage.
   const request = new Request(TARGET_URL, { mode: 'no-cors',
                                             cache: 'reload' });
   const net_response = await frame.contentWindow.fetch(request);

   // Compute a padded usage value based on the response returned from our
   // outer fetch.
   const cache = await caches.open('padding');
   // Make sure to use the URL and not the full request.  The main window
   // and service worker requests may have different headers which can
   // throw off the size comparison.
   await cache.put(request.url, net_response);
   const usage = (await navigator.storage.estimate()).usageDetails.caches;
   await cache.delete(request.url);

   // Compare our usage against the service worker usage.  They should be the
   // same.  While a random padding is generated when a response is loaded
   // over the network, that padding will be propagated through the service
   // worker boundary to the outer fetch.
   const sw_usage = await message_promise;
   assert_equals(usage, sw_usage,
                 'The padding should propogate through the service worker ' +
                 'respondWith().');

 }, 'Cache padding propagates through a service worker respondWith().');

 promise_test(async t => {
   const script = './resources/padding-install-sw.js';
   const scope = './resources/padding-install-frame.html';

   // populate http cache
   await usage({ cache: 'reload' });

   // Get usage for a response stored on the main thread.  This will
   // not include any code cache.
   const main_window_usage = await usage({ cache: 'force-cache' });

   // A utility function for creating a promise that waits for a message
   // from the service worker sending usage information.
   function make_message_promise() {
     return new Promise(resolve => {
       navigator.serviceWorker.addEventListener('message',
           function onMessage(evt) {
             if (!('usage' in evt.data))
               return;
             navigator.serviceWorker.removeEventListener('message', onMessage);
             resolve(evt.data.usage);
           });
     });
   }

   // Prepare to get a usage value from the service worker.
   const message_promise_1 = make_message_promise();

   // Register a service worker that stores and computes usage in its install
   // event.  This will result in code cache being stored as side data.
   const reg_1 = await service_worker_unregister_and_register(t, script, scope);
   t.add_cleanup(() => reg_1.unregister());
   await wait_for_state(t, reg_1.installing, 'activated');

   // Wait for the service worker usage including code cache.
   const sw_usage_1 = await message_promise_1;

   assert_true(sw_usage_1 > main_window_usage,
               'Usage with code cache should always be greater than ' +
               'main_window_usage.');

   // Prepare to get another usage value from a service worker.
   const message_promise_2 = make_message_promise();

   // Register a second service worker to get another usage with code cache.
   const reg_2 = await service_worker_unregister_and_register(t, script, scope + '-2');
   t.add_cleanup(() => reg_2.unregister());
   await wait_for_state(t, reg_2.installing, 'activated');

   // The usage with code cache should be stable.
   const sw_usage_2 = await message_promise_2;
   assert_equals(sw_usage_1, sw_usage_2,
                 'Usage with code cache should be stable for a response ' +
                 'loaded from http cache.');
 }, 'Code cache padding should be stable.');

 </script>
	<!doctype html>
	<title>Cache Storage: verify cache_storage padding behavior</title>
	<link rel="help" href="https://w3c.github.io/ServiceWorker/#cache-interface">
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="/common/get-host-info.sub.js"></script>
	<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
	<script>
	'use strict';

	const tmp_url = new URL('resources/simple.js', self.location);
	tmp_url.hostname = get_host_info().REMOTE_HOST;
	const TARGET_URL = tmp_url.href;

	async function usage(init) {
	const cache = await caches.open('padding');
	if (!init.mode)
	init.mode = 'no-cors';
	let r = await fetch(TARGET_URL, init);
	if (init.mode == 'no-cors')
	assert_equals(r.type, 'opaque');
	const clone = r.clone();
	// Note, this stores the response under a Request key that has a different
	// url than what we fetched above. This is purposeful to ensure
	// that we are varying on how the Response was loaded and not on the Request
	// key.
	const cache_url = '/foo';
	await cache.put(cache_url, r);
	const usage1 = (await navigator.storage.estimate()).usageDetails.caches;
	await cache.delete(cache_url);

	await cache.put(cache_url, clone);
	const usage2 = (await navigator.storage.estimate()).usageDetails.caches;
	await cache.delete(cache_url);

	assert_equals(usage1, usage2, 'cloned response have the same padding size');
	return usage1;
	}

	promise_test(async t => {
	const usage1 = await usage({ cache: 'reload' });
	const usage2 = await usage({ cache: 'reload' });
	assert_not_equals(usage1, usage2,
	'Responses loaded from network should have different ' +
	'padding size.');
	}, 'Cache padding varies if loaded from network.');

	promise_test(async t => {
	// populate http cache
	await usage({ cache: 'reload' });

	const cache_usage1 = await usage({ cache: 'force-cache' });
	const cache_usage2 = await usage({ cache: 'force-cache' });

	assert_equals(cache_usage1, cache_usage2,
	'Responses loaded from http cache should have the same ' +
	'padding size.');

	// repopulate http cache
	await usage({ cache: 'reload' });

	const cache_usage3 = await usage({ cache: 'force-cache' });
	const cache_usage4 = await usage({ cache: 'force-cache' });

	assert_not_equals(cache_usage1, cache_usage3,
	'An updated http cache entry should result in a ' +
	'different padding size.');
	assert_equals(cache_usage3, cache_usage4,
	'Responses loaded from http cache should have the same ' +
	'padding size.');
	}, 'Cache padding is stable if loaded from http cache.');

	promise_test(async t => {
	// Determine the actual size difference between GET and HEAD requests.
	const cors_get_usage = await usage({ mode: 'cors', method: 'GET' });
	const cors_head_usage = await usage({ mode: 'cors', method: 'HEAD' });
	const cors_diff = cors_get_usage - cors_head_usage;

	const net_get_usage = await usage({ method: 'GET', cache: 'reload' });
	const net_head_usage = await usage({ method: 'HEAD', cache: 'reload' });
	const opaque_net_diff = net_get_usage - net_head_usage;

	assert_not_equals(net_get_usage, net_head_usage,
	'Responses loaded from network with different methods ' +
	'should have different padding size.');
	assert_not_equals(opaque_net_diff, cors_diff,
	'Responses loaded from network with different methods ' +
	'should have usages that differ more than actual ' +
	'response size.');

	// populate http cache
	await usage({ cache: 'reload' });

	const cache_get_usage = await usage({ method: 'GET', cache: 'force-cache' });
	const cache_head_usage = await usage({ method: 'HEAD', cache: 'force-cache' });
	const opaque_cache_diff = cache_get_usage - cache_head_usage;

	assert_not_equals(cache_get_usage, cache_head_usage,
	'Responses loaded from http cache with different methods ' +
	'should have the different padding size.');
	assert_not_equals(opaque_cache_diff, cors_diff,
	'Responses loaded from http cache with different methods ' +
	'should have usages that differ more than actual ' +
	'response size.');
	}, 'Cache padding varies with request method.');

	promise_test(async t => {
	const cache1 = await caches.open('padding');
	const cache2 = await caches.open('padding-2');

	const net_response = await fetch(TARGET_URL, { mode: 'no-cors',
	cache: 'reload' });
	await cache1.put(TARGET_URL, net_response);
	const usage1 = (await navigator.storage.estimate()).usageDetails.caches;

	const cache_response = await cache1.match(TARGET_URL);
	await cache2.put(TARGET_URL, cache_response);
	await cache1.delete(TARGET_URL);
	const usage2 = (await navigator.storage.estimate()).usageDetails.caches;
	await cache2.delete(TARGET_URL);

	assert_equals(usage1, usage2,
	'The padding value should follow a response loaded from ' +
	'cache_storage.');

	}, 'Cache padding follows a response loaded from cache_storage.');

	promise_test(async t => {
	const script = './resources/padding-fetch-sw.js';
	const scope = './resources/padding-fetch-frame.html';

	// Setup a service worker.
	const reg = await service_worker_unregister_and_register(t, script, scope);
	t.add_cleanup(() => reg.unregister());
	await wait_for_state(t, reg.installing, 'activated');

	// Setup an iframe controlled by the service worker.
	const frame = await with_iframe(scope);
	t.add_cleanup(() => frame.remove());

	// The service worker will send a padded usage value via postMessage.
	// Prepare to receive this message.
	const message_promise = new Promise(resolve => {
	frame.contentWindow.navigator.serviceWorker.addEventListener('message',
	evt => {
	if (!('usage' in evt.data))
	return;
	resolve(evt.data.usage);
	});
	});

	// Fetch an opaque response from the network. This will hit the
	// service worker fetch handler which will compute a padded usage
	// value before allowing this outer fetch to resolve. The SW
	// usage value is sent via an out-of-band postMessage.
	const request = new Request(TARGET_URL, { mode: 'no-cors',
	cache: 'reload' });
	const net_response = await frame.contentWindow.fetch(request);

	// Compute a padded usage value based on the response returned from our
	// outer fetch.
	const cache = await caches.open('padding');
	// Make sure to use the URL and not the full request. The main window
	// and service worker requests may have different headers which can
	// throw off the size comparison.
	await cache.put(request.url, net_response);
	const usage = (await navigator.storage.estimate()).usageDetails.caches;
	await cache.delete(request.url);

	// Compare our usage against the service worker usage. They should be the
	// same. While a random padding is generated when a response is loaded
	// over the network, that padding will be propagated through the service
	// worker boundary to the outer fetch.
	const sw_usage = await message_promise;
	assert_equals(usage, sw_usage,
	'The padding should propogate through the service worker ' +
	'respondWith().');

	}, 'Cache padding propagates through a service worker respondWith().');

	promise_test(async t => {
	const script = './resources/padding-install-sw.js';
	const scope = './resources/padding-install-frame.html';

	// populate http cache
	await usage({ cache: 'reload' });

	// Get usage for a response stored on the main thread. This will
	// not include any code cache.
	const main_window_usage = await usage({ cache: 'force-cache' });

	// A utility function for creating a promise that waits for a message
	// from the service worker sending usage information.
	function make_message_promise() {
	return new Promise(resolve => {
	navigator.serviceWorker.addEventListener('message',
	function onMessage(evt) {
	if (!('usage' in evt.data))
	return;
	navigator.serviceWorker.removeEventListener('message', onMessage);
	resolve(evt.data.usage);
	});
	});
	}

	// Prepare to get a usage value from the service worker.
	const message_promise_1 = make_message_promise();

	// Register a service worker that stores and computes usage in its install
	// event. This will result in code cache being stored as side data.
	const reg_1 = await service_worker_unregister_and_register(t, script, scope);
	t.add_cleanup(() => reg_1.unregister());
	await wait_for_state(t, reg_1.installing, 'activated');

	// Wait for the service worker usage including code cache.
	const sw_usage_1 = await message_promise_1;

	assert_true(sw_usage_1 > main_window_usage,
	'Usage with code cache should always be greater than ' +
	'main_window_usage.');

	// Prepare to get another usage value from a service worker.
	const message_promise_2 = make_message_promise();

	// Register a second service worker to get another usage with code cache.
	const reg_2 = await service_worker_unregister_and_register(t, script, scope + '-2');
	t.add_cleanup(() => reg_2.unregister());
	await wait_for_state(t, reg_2.installing, 'activated');

	// The usage with code cache should be stable.
	const sw_usage_2 = await message_promise_2;
	assert_equals(sw_usage_1, sw_usage_2,
	'Usage with code cache should be stable for a response ' +
	'loaded from http cache.');
	}, 'Code cache padding should be stable.');

	</script>