1. Let target be the MediaRecorder context object.
2. Let timeslice be the method's first argument, if provided, or undefined.
3. If state is not inactive, throw an InvalidStateError DOMException and abort these steps.
4. If the stream's isolation properties disallow access from this MediaRecorder, throw a SecurityError DOMException and abort these steps.
5. Set state to recording, and run the following steps in parallel:
   1. Once media becomes available from one or more of the stream's tracks, start gathering the data into a Blob ([ FILE-API]) blob and queue a task, using the DOM manipulation task source, to fire an event named start at target.
   2. If at any point the stream's isolation properties change so that MediaRecorder is no longer allowed access to it, the UA MUST immediately stop gathering data, discard any data that it has gathered, and queue a task, using the DOM manipulation task source, that runs the following steps:
      1. Set state to inactive.
      2. Fire an error event named SecurityError at target.
      3. Fire an event named stop at target.
   3. If the UA at any point is unable to continue gathering data for reasons other than isolation properties, it MUST stop gathering data, and queue a task, using the DOM manipulation task source, that runs the following steps:
      1. Set state to inactive.
      2. Fire an error event named UnknownError at target.
      3. Fire a blob event named dataavailable at target with blob.
      4. Fire an event named stop at target.
   4. If timeslice is not undefined, then once a minimum of timeslice milliseconds of data have been collected, or some minimum time slice imposed by the UA, whichever is greater, start gathering data into a a new Blob blob, and queue a task, using the DOM manipulation task source, that fires a blob event named dataavailable at target with blob. Note that an undefined value of timeslice will be understood as the largest long value.
   5. If all recorded tracks become ended [GETUSERMEDIA], then stop gathering data, and queue a task, using the DOM manipulation task source, that runs the following steps:
      1. Set state to inactive.
      2. Fire a blob event named dataavailable at target with blob.
      3. Fire an event named stop at target.
6. return undefined.

Note that stop(), requestData(), and pause() also affect the recording behavior.

The UA MUST record the MediaStream in such a way that the original Tracks can be retrieved at playback time. When multiple Blobs are returned (because of timeslice or requestData), the individual Blobs need not be playable, but the combination of all the Blobs from a completed recording MUST be playable.

If any Track within the MediaStream is muted at any time (i.e., if its muted flag is set to true), the UA MUST insert black frames or silence until the Track is unmuted, or record nothing, depending on the value of ignoreMutedMedia.

1. If state is inactive, throw an InvalidStateError DOMException and terminate these steps. Otherwise the UA MUST queue a task, using the DOM manipulation task source, that runs the following steps:
   1. Set state to inactive and stop gathering data.
   2. Let blob be the Blob of collected data so far and let target be the MediaRecorder context object, then fire a blob event named dataavailable at target with blob.
   3. Fire an event named stop at target.
2. return undefined.

1. If state is inactive throw an InvalidStateError DOMException and terminate these steps. Otherwise the UA MUST queue a task, using the DOM manipulation task source, that runs the following steps:
   1. Set state to paused.
   2. Stop gathering data into blob (but keep it available so that recording can be resumed in the future).
   3. Let target be the MediaRecorder context object. Fire an event named pause at target.
2. return undefined.

1. If state is inactive throw an InvalidStateError DOMException and terminate these steps. Otherwise the UA MUST queue a task, using the DOM manipulation task source, that runs the following steps:
   1. Set state to recording.
   2. Resume (or continue) gathering data into the current blob.
   3. Let target be the MediaRecorder context object. Fire an event named resume at target.
2. return undefined.

1. If state is not recording throw an InvalidStateError DOMException and terminate these steps. Otherwise the UA MUST queue a task, using the DOM manipulation task source, that runs the following steps:
   1. Let blob be the Blob of collected data so far and let target be the MediaRecorder context object, then fire a blob event named dataavailable at target with blob. (Note that blob will be empty if no data has been gathered yet.)
   2. Create a new Blob and gather subsequent data into it.
2. return undefined.

1. If type is an empty string, then return true (note that this case is essentially equivalent to leaving up to the UA the choice of container and codecs on constructor).
2. If type does not contain a valid MIME type string, then return false.
3. If type contains a media type or media subtype that the MediaRecorder does not support, then return false.
4. If type contains a media container that the MediaSource does not support, then return false.
5. If type contains a codec that the MediaSource does not support, then return false.
6. If the MediaRecorder does not support the specified combination of media type/subtype, codecs and container then return false.
7. Return true.