path: root/testing/web-platform/tests/media-source/dedicated-worker/mediasource-worker-duration.js

importScripts("mediasource-worker-util.js");

// Note, we do not use testharness.js utilities within the worker context
// because it also communicates using postMessage to the main HTML document's
// harness, and would confuse the test case message parsing there.

let util = new MediaSourceWorkerUtil();
let sourceBuffer;

// Phases of this test case, in sequence:
const testPhase = {
  // Main thread verifies initial unattached HTMLMediaElement duration is NaN
  // and readyState is HAVE_NOTHING, then starts this worker.
  // This worker creates a MediaSource, verifies its initial duration
  // is NaN, creates an object URL for the MediaSource and sends the URL to the
  // main thread.
  kInitial: "Initial",

  // Main thread receives MediaSourceHandle, re-verifies that the media element
  // duration is still NaN and readyState is still HAVE_NOTHING, and then sets
  // the handle as the srcObject of the media element, eventually causing worker
  // mediaSource 'onsourceopen' event dispatch.
  kAttaching: "Awaiting sourceopen event that signals attachment is setup",

  kRequestNaNDurationCheck:
      "Sending request to main thread to verify expected duration of the freshly setup attachment",
  kConfirmNaNDurationResult:
      "Checking that main thread correctly ACK'ed the freshly setup attachment's duration verification request",

  kRequestHaveNothingReadyStateCheck:
      "Sending request to main thread to verify expected readyState of HAVE_NOTHING of the freshly setup attachment",
  kConfirmHaveNothingReadyStateResult:
      "Checking that main thread correctly ACK'ed the freshly setup attachment's readyState HAVE_NOTHING verification request",

  kRequestSetDurationCheck:
      "Sending request to main thread to verify explicitly set duration before any media data has been appended",
  kConfirmSetDurationResult:
      "Checking that main thread correctly ACK'ed the duration verification request of explicitly set duration before any media data has been appended",

  kRequestHaveNothingReadyStateRecheck:
      "Sending request to main thread to recheck that the readyState is still HAVE_NOTHING",
  kConfirmHaveNothingReadyStateRecheckResult:
      "Checking that main thread correctly ACK'ed the request to recheck readyState of HAVE_NOTHING",

  kRequestAwaitNewDurationCheck:
      "Buffering media and then sending request to main thread to await duration reaching the expected value due to buffering",
  kConfirmAwaitNewDurationResult:
      "Checking that main thread correctly ACK'ed the request to await duration reaching the expected value due to buffering",

  kRequestAtLeastHaveMetadataReadyStateCheck:
      "Sending request to main thread to verify expected readyState of at least HAVE_METADATA due to buffering",
  kConfirmAtLeastHaveMetadataReadyStateResult:
      "Checking that main thread correctly ACK'ed the request to verify expected readyState of at least HAVE_METADATA due to buffering",

};

let phase = testPhase.kInitial;

// Setup handler for receipt of attachment completion.
util.mediaSource.addEventListener("sourceopen", () => {
  assert(phase === testPhase.kAttaching, "Unexpected sourceopen received by Worker mediaSource.");
  phase = testPhase.kRequestNaNDurationCheck;
  processPhase();
}, { once : true });

// Setup handler for receipt of acknowledgement of successful verifications from
// main thread. |ackVerificationData| contains the round-tripped verification
// request that the main thread just sent, and is used in processPhase to ensure
// the ACK for this phase matched the request for verification.
let ackVerificationData;
onmessage = e => {
  if (e.data === undefined || e.data.subject !== messageSubject.ACK_VERIFIED || e.data.info === undefined) {
    postMessage({
      subject: messageSubject.ERROR,
      info: "Invalid message received by Worker"
    });
    return;
  }

  ackVerificationData = e.data.info;
  processPhase(/* isResponseToAck */ true);
};

processPhase();


// Returns true if checks succeed, false otherwise.
function checkAckVerificationData(expectedRequest) {

  // Compares only subject and info fields. Uses logic similar to testharness.js's
  // same_value(x,y) to correctly handle NaN, but doesn't distinguish +0 from -0.
  function messageValuesEqual(m1, m2) {
    if (m1.subject !== m1.subject) {
      // NaN case
      if (m2.subject === m2.subject)
        return false;
    } else if (m1.subject !== m2.subject) {
      return false;
    }

    if (m1.info !== m1.info) {
      // NaN case
      return (m2.info !== m2.info);
    }

    return m1.info === m2.info;
  }

  if (messageValuesEqual(expectedRequest, ackVerificationData)) {
    ackVerificationData = undefined;
    return true;
  }

  postMessage({
    subject: messageSubject.ERROR,
    info: "ACK_VERIFIED message from main thread was for a mismatching request for this phase. phase=[" + phase +
          "], expected request that would produce ACK in this phase=[" + JSON.stringify(expectedRequest) +
          "], actual request reported with the ACK=[" + JSON.stringify(ackVerificationData) + "]"
  });

  ackVerificationData = undefined;
  return false;
}

function bufferMediaAndSendDurationVerificationRequest() {
  sourceBuffer = util.mediaSource.addSourceBuffer(util.mediaMetadata.type);
  sourceBuffer.onerror = (err) => {
    postMessage({ subject: messageSubject.ERROR, info: err });
  };
  sourceBuffer.onupdateend = () => {
    // Sanity check the duration.
    // Unnecessary for this buffering, except helps with test coverage.
    var duration = util.mediaSource.duration;
    if (isNaN(duration) || duration <= 0.0) {
      postMessage({
        subject: messageSubject.ERROR,
        info: "mediaSource.duration " + duration + " is not within expected range (0,1)"
      });
      return;
    }

    // Await the main thread media element duration matching the worker
    // mediaSource duration.
    postMessage(getAwaitCurrentDurationRequest());
  };

  util.mediaLoadPromise.then(mediaData => { sourceBuffer.appendBuffer(mediaData); },
                             err => { postMessage({ subject: messageSubject.ERROR, info: err }) });
}


function getAwaitCurrentDurationRequest() {
  // Sanity check that we have a numeric duration value now.
  const dur = util.mediaSource.duration;
  assert(!Number.isNaN(dur), "Unexpected NaN duration in worker");
  return { subject: messageSubject.AWAIT_DURATION, info: dur };
}

function assert(conditionBool, description) {
  if (conditionBool !== true) {
    postMessage({
      subject: messageSubject.ERROR,
      info: "Current test phase [" + phase + "] failed worker assertion. " + description
    });
  }
}

function processPhase(isResponseToAck = false) {
  assert(!isResponseToAck || (phase !== testPhase.kInitial && phase !== testPhase.kAttaching),
      "Phase does not expect verification ack receipt from main thread");

  // Some static request messages useful in transmission and ACK verification.
  const nanDurationCheckRequest = { subject: messageSubject.VERIFY_DURATION, info: NaN };
  const haveNothingReadyStateCheckRequest = { subject: messageSubject.VERIFY_HAVE_NOTHING };
  const setDurationCheckRequest = { subject: messageSubject.AWAIT_DURATION, info: 0.1 };
  const atLeastHaveMetadataReadyStateCheckRequest = { subject: messageSubject.VERIFY_AT_LEAST_HAVE_METADATA };

  switch (phase) {

    case testPhase.kInitial:
      assert(Number.isNaN(util.mediaSource.duration), "Initial unattached MediaSource duration must be NaN, but instead is " + util.mediaSource.duration);
      phase = testPhase.kAttaching;
      let handle = util.mediaSource.handle;
      postMessage({ subject: messageSubject.HANDLE, info: handle }, { transfer: [handle] } );
      break;

    case testPhase.kAttaching:
      postMessage({
        subject: messageSubject.ERROR,
        info: "kAttaching phase is handled by main thread and by worker onsourceopen, not this switch case."
      });
      break;

    case testPhase.kRequestNaNDurationCheck:
      assert(!isResponseToAck);
      postMessage(nanDurationCheckRequest);
      phase = testPhase.kConfirmNaNDurationResult;
      break;

    case testPhase.kConfirmNaNDurationResult:
      assert(isResponseToAck);
      if (checkAckVerificationData(nanDurationCheckRequest)) {
        phase = testPhase.kRequestHaveNothingReadyStateCheck;
        processPhase();
      }
      break;

    case testPhase.kRequestHaveNothingReadyStateCheck:
      assert(!isResponseToAck);
      postMessage(haveNothingReadyStateCheckRequest);
      phase = testPhase.kConfirmHaveNothingReadyStateResult;
      break;

    case testPhase.kConfirmHaveNothingReadyStateResult:
      assert(isResponseToAck);
      if (checkAckVerificationData(haveNothingReadyStateCheckRequest)) {
        phase = testPhase.kRequestSetDurationCheck;
        processPhase();
      }
      break;

    case testPhase.kRequestSetDurationCheck:
      assert(!isResponseToAck);
      const newDuration = setDurationCheckRequest.info;
      assert(!Number.isNaN(newDuration) && newDuration > 0);

      // Set the duration, then request verification.
      util.mediaSource.duration = newDuration;
      postMessage(setDurationCheckRequest);
      phase = testPhase.kConfirmSetDurationResult;
      break;

    case testPhase.kConfirmSetDurationResult:
      assert(isResponseToAck);
      if (checkAckVerificationData(setDurationCheckRequest)) {
        phase = testPhase.kRequestHaveNothingReadyStateRecheck;
        processPhase();
      }
      break;

    case testPhase.kRequestHaveNothingReadyStateRecheck:
      assert(!isResponseToAck);
      postMessage(haveNothingReadyStateCheckRequest);
      phase = testPhase.kConfirmHaveNothingReadyStateRecheckResult;
      break;

    case testPhase.kConfirmHaveNothingReadyStateRecheckResult:
      assert(isResponseToAck);
      if (checkAckVerificationData(haveNothingReadyStateCheckRequest)) {
        phase = testPhase.kRequestAwaitNewDurationCheck;
        processPhase();
      }
      break;

    case testPhase.kRequestAwaitNewDurationCheck:
      assert(!isResponseToAck);
      bufferMediaAndSendDurationVerificationRequest();
      phase = testPhase.kConfirmAwaitNewDurationResult;
      break;

    case testPhase.kConfirmAwaitNewDurationResult:
      assert(isResponseToAck);
      if (checkAckVerificationData(getAwaitCurrentDurationRequest())) {
        phase = testPhase.kRequestAtLeastHaveMetadataReadyStateCheck;
        processPhase();
      }
      break;

    case testPhase.kRequestAtLeastHaveMetadataReadyStateCheck:
      assert(!isResponseToAck);
      postMessage(atLeastHaveMetadataReadyStateCheckRequest);
      phase = testPhase.kConfirmAtLeastHaveMetadataReadyStateResult;
      break;

    case testPhase.kConfirmAtLeastHaveMetadataReadyStateResult:
      assert(isResponseToAck);
      if (checkAckVerificationData(atLeastHaveMetadataReadyStateCheckRequest)) {
        postMessage({ subject: messageSubject.WORKER_DONE });
      }
      phase = "No further phase processing should occur once WORKER_DONE message has been sent";
      break;

    default:
      postMessage({
        subject: messageSubject.ERROR,
        info: "Unexpected test phase in worker:" + phase,
      });
  }

}