<!DOCTYPE html>
<title>Prerendering cannot invoke the Idle Detection API</title>
<meta name="timeout" content="long">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/common/utils.js"></script>
<script src="../resources/utils.js"></script>
<script src="resources/utils.js"></script>

<body>
<script>
setup(() => assertSpeculationRulesIsSupported());

promise_test(async t => {
  const uid = token();
  const bc = new PrerenderChannel('prerender-channel', uid);

  const gotMessage = new Promise(resolve => {
    bc.addEventListener('message', e => {
      resolve(e.data);
    }, {
      once: true
    });
  });

  // Start prerendering a page that attempts to invoke the Idle Detection API.
  // This API is activation-gated so it's expected to fail:
  // https://wicg.github.io/nav-speculation/prerendering.html#activation-gated
  startPrerendering(`resources/idle-detection.https.html?uid=${uid}`);
  const result = await gotMessage;
  assert_equals(result, 'NotAllowedError');
  bc.close();
}, `prerendering pages should not be able to invoke the Idle Detection API`);
</script>
