<!DOCTYPE HTML>
<html>
<head>
  <title>Test that credentials are sent properly in a cross-origin but same-site nested context</title>
  <script src='/resources/testharness.js'></script>
  <script src='/resources/testharnessreport.js'></script>
  <script src='resources/report-helper.js'></script>
</head>
<body>
  <script>
    const base_url = `${location.protocol}//${location.host}`;
    const endpoint = `${base_url}/reporting/resources/report.py`;
    const id = 'd0d517bf-891b-457a-b970-8b2b2c81a0bf';

    promise_test(async t => {
      // If this is not run from the expected origin, then the A->A->www.A frame embedding will not be correct,
      // and the cookies set in the top-level page will never be returned with the reports.
      assert_true(location.href.startsWith("https://{{hosts[][]}}:{{ports[https][0]}}/"),
                  "Test running on unexpected origin; subsequent assertions will fail.");

      // Set credentials, and set up test to clear them afterwards. Cookies are set with the Domain
      // attribute, so that they may be sent to same-site resources.
      await fetch('/cookies/resources/setSameSiteDomain.py?reporting', {mode: 'no-cors', credentials: 'include', cache: 'no-store'});
      t.add_cleanup(() => fetch("/cookies/resources/dropSameSite.py", {mode: 'no-cors', credentials: 'include', cache: 'no-store'}));

      // Insert a same-origin frame, which will then frame a same-site but cross-origin page to
      // trigger a CSP error.
      const frame = document.createElement('iframe');
      frame.src = "https://{{hosts[][]}}:{{ports[https][0]}}/reporting/resources/middle-frame.https.sub.html?host={{hosts[][www]}}";

      // Wait for the inner frame to signal that the report has been generated.
      await new Promise(resolve => {
        window.addEventListener('message', ev => {
          if (ev.data === "done")
            resolve(ev.data);
          });
        document.body.appendChild(frame);
      });

      const reports = await pollReports(endpoint, id);
      checkReportExists(reports, 'csp-violation', "https://{{hosts[][www]}}:{{ports[https][0]}}/reporting/resources/same-origin-report.https.sub.html");

      // All credentials set at the top-level should be received.
      const cookies = await pollCookies(endpoint, id);
      assert_equals(cookies.samesite_none, "[samesite_none=reporting]", "Credential value was correct");
      assert_equals(cookies.samesite_unspecified, "[samesite_unspecified=reporting]", "Credential value was correct");
      assert_equals(cookies.samesite_lax, "[samesite_lax=reporting]", "Credential value was correct");
      assert_equals(cookies.samesite_strict, "[samesite_strict=reporting]", "Credential value was correct");
      assert_equals(Object.keys(cookies).length, 4, "No additional cookies were received");

    }, "Reporting endpoints received credentials.");
  </script>
</body>
</html>
