Add m-esr52 at 52.6.0

1 files changed, 861 insertions, 0 deletions

diff --git a/dom/media/MediaDecoder.h b/dom/media/MediaDecoder.h
new file mode 100644
index 000000000..825bbbd2c
--- /dev/null
+++ b/dom/media/MediaDecoder.h
@@ -0,0 +1,861 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#if !defined(MediaDecoder_h_)
+#define MediaDecoder_h_
+
+#include "mozilla/Atomics.h"
+#include "mozilla/CDMProxy.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/ReentrantMonitor.h"
+#include "mozilla/StateMirroring.h"
+#include "mozilla/StateWatching.h"
+
+#include "mozilla/dom/AudioChannelBinding.h"
+
+#include "necko-config.h"
+#include "nsAutoPtr.h"
+#include "nsCOMPtr.h"
+#include "nsIObserver.h"
+#include "nsISupports.h"
+#include "nsITimer.h"
+
+#include "AbstractMediaDecoder.h"
+#include "DecoderDoctorDiagnostics.h"
+#include "MediaDecoderOwner.h"
+#include "MediaEventSource.h"
+#include "MediaMetadataManager.h"
+#include "MediaResource.h"
+#include "MediaResourceCallback.h"
+#include "MediaStatistics.h"
+#include "MediaStreamGraph.h"
+#include "TimeUnits.h"
+#include "SeekTarget.h"
+
+class nsIStreamListener;
+class nsIPrincipal;
+
+namespace mozilla {
+
+namespace dom {
+class Promise;
+}
+
+class VideoFrameContainer;
+class MediaDecoderStateMachine;
+
+enum class MediaEventType : int8_t;
+
+// GetCurrentTime is defined in winbase.h as zero argument macro forwarding to
+// GetTickCount() and conflicts with MediaDecoder::GetCurrentTime implementation.
+#ifdef GetCurrentTime
+#undef GetCurrentTime
+#endif
+
+class MediaDecoder : public AbstractMediaDecoder
+{
+public:
+  struct SeekResolveValue {
+    bool mAtEnd;
+  };
+
+  // Used to register with MediaResource to receive notifications which will
+  // be forwarded to MediaDecoder.
+  class ResourceCallback : public MediaResourceCallback {
+    // Throttle calls to MediaDecoder::NotifyDataArrived()
+    // to be at most once per 500ms.
+    static const uint32_t sDelay = 500;
+
+  public:
+    // Start to receive notifications from ResourceCallback.
+    void Connect(MediaDecoder* aDecoder);
+    // Called upon shutdown to stop receiving notifications.
+    void Disconnect();
+
+  private:
+    /* MediaResourceCallback functions */
+    MediaDecoderOwner* GetMediaOwner() const override;
+    void SetInfinite(bool aInfinite) override;
+    void NotifyNetworkError() override;
+    void NotifyDecodeError() override;
+    void NotifyDataArrived() override;
+    void NotifyBytesDownloaded() override;
+    void NotifyDataEnded(nsresult aStatus) override;
+    void NotifyPrincipalChanged() override;
+    void NotifySuspendedStatusChanged() override;
+    void NotifyBytesConsumed(int64_t aBytes, int64_t aOffset) override;
+
+    static void TimerCallback(nsITimer* aTimer, void* aClosure);
+
+    // The decoder to send notifications. Main-thread only.
+    MediaDecoder* mDecoder = nullptr;
+    nsCOMPtr<nsITimer> mTimer;
+    bool mTimerArmed = false;
+  };
+
+  typedef MozPromise<SeekResolveValue, bool /* aIgnored */, /* IsExclusive = */ true> SeekPromise;
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  // Enumeration for the valid play states (see mPlayState)
+  enum PlayState {
+    PLAY_STATE_START,
+    PLAY_STATE_LOADING,
+    PLAY_STATE_PAUSED,
+    PLAY_STATE_PLAYING,
+    PLAY_STATE_ENDED,
+    PLAY_STATE_SHUTDOWN
+  };
+
+  // Must be called exactly once, on the main thread, during startup.
+  static void InitStatics();
+
+  explicit MediaDecoder(MediaDecoderOwner* aOwner);
+
+  // Return a callback object used to register with MediaResource to receive
+  // notifications.
+  MediaResourceCallback* GetResourceCallback() const;
+
+  // Create a new decoder of the same type as this one.
+  // Subclasses must implement this.
+  virtual MediaDecoder* Clone(MediaDecoderOwner* aOwner) = 0;
+  // Create a new state machine to run this decoder.
+  // Subclasses must implement this.
+  virtual MediaDecoderStateMachine* CreateStateMachine() = 0;
+
+  // Cleanup internal data structures. Must be called on the main
+  // thread by the owning object before that object disposes of this object.
+  virtual void Shutdown();
+
+  // Notified by the shutdown manager that XPCOM shutdown has begun.
+  // The decoder should notify its owner to drop the reference to the decoder
+  // to prevent further calls into the decoder.
+  void NotifyXPCOMShutdown();
+
+  // Start downloading the media. Decode the downloaded data up to the
+  // point of the first frame of data.
+  // This is called at most once per decoder, after Init().
+  virtual nsresult Load(nsIStreamListener** aListener);
+
+  // Called in |Load| to open mResource.
+  nsresult OpenResource(nsIStreamListener** aStreamListener);
+
+  // Called if the media file encounters a network error.
+  void NetworkError();
+
+  // Get the current MediaResource being used. Its URI will be returned
+  // by currentSrc. Returns what was passed to Load(), if Load() has been called.
+  // Note: The MediaResource is refcounted, but it outlives the MediaDecoder,
+  // so it's OK to use the reference returned by this function without
+  // refcounting, *unless* you need to store and use the reference after the
+  // MediaDecoder has been destroyed. You might need to do this if you're
+  // wrapping the MediaResource in some kind of byte stream interface to be
+  // passed to a platform decoder.
+  MediaResource* GetResource() const final override
+  {
+    return mResource;
+  }
+  void SetResource(MediaResource* aResource)
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    mResource = aResource;
+  }
+
+  // Return the principal of the current URI being played or downloaded.
+  virtual already_AddRefed<nsIPrincipal> GetCurrentPrincipal();
+
+  // Return the time position in the video stream being
+  // played measured in seconds.
+  virtual double GetCurrentTime();
+
+  // Seek to the time position in (seconds) from the start of the video.
+  // If aDoFastSeek is true, we'll seek to the sync point/keyframe preceeding
+  // the seek target.
+  virtual nsresult Seek(double aTime, SeekTarget::Type aSeekType,
+                        dom::Promise* aPromise = nullptr);
+
+  // Initialize state machine and schedule it.
+  nsresult InitializeStateMachine();
+
+  // Start playback of a video. 'Load' must have previously been
+  // called.
+  virtual nsresult Play();
+
+  // Notify activity of the decoder owner is changed.
+  virtual void NotifyOwnerActivityChanged(bool aIsVisible);
+
+  // Pause video playback.
+  virtual void Pause();
+  // Adjust the speed of the playback, optionally with pitch correction,
+  virtual void SetVolume(double aVolume);
+
+  virtual void SetPlaybackRate(double aPlaybackRate);
+  void SetPreservesPitch(bool aPreservesPitch);
+
+  // Directs the decoder to not preroll extra samples until the media is
+  // played. This reduces the memory overhead of media elements that may
+  // not be played. Note that seeking also doesn't cause us start prerolling.
+  void SetMinimizePrerollUntilPlaybackStarts();
+
+  // All MediaStream-related data is protected by mReentrantMonitor.
+  // We have at most one DecodedStreamData per MediaDecoder. Its stream
+  // is used as the input for each ProcessedMediaStream created by calls to
+  // captureStream(UntilEnded). Seeking creates a new source stream, as does
+  // replaying after the input as ended. In the latter case, the new source is
+  // not connected to streams created by captureStreamUntilEnded.
+
+  // Add an output stream. All decoder output will be sent to the stream.
+  // The stream is initially blocked. The decoder is responsible for unblocking
+  // it while it is playing back.
+  virtual void AddOutputStream(ProcessedMediaStream* aStream, bool aFinishWhenEnded);
+  // Remove an output stream added with AddOutputStream.
+  virtual void RemoveOutputStream(MediaStream* aStream);
+
+  // Return the duration of the video in seconds.
+  virtual double GetDuration();
+
+  // Return true if the stream is infinite (see SetInfinite).
+  bool IsInfinite() const;
+
+  // Called by MediaResource when some data has been received.
+  // Call on the main thread only.
+  virtual void NotifyBytesDownloaded();
+
+  // Called as data arrives on the stream and is read into the cache.  Called
+  // on the main thread only.
+  void NotifyDataArrived();
+
+  // Return true if we are currently seeking in the media resource.
+  // Call on the main thread only.
+  bool IsSeeking() const;
+
+  // Return true if the decoder has reached the end of playback.
+  bool IsEnded() const;
+
+  // Return true if the MediaDecoderOwner's error attribute is not null.
+  // Must be called before Shutdown().
+  bool OwnerHasError() const;
+
+  already_AddRefed<GMPCrashHelper> GetCrashHelper() override;
+
+protected:
+  // Updates the media duration. This is called while the media is being
+  // played, calls before the media has reached loaded metadata are ignored.
+  // The duration is assumed to be an estimate, and so a degree of
+  // instability is expected; if the incoming duration is not significantly
+  // different from the existing duration, the change request is ignored.
+  // If the incoming duration is significantly different, the duration is
+  // changed, this causes a durationchanged event to fire to the media
+  // element.
+  void UpdateEstimatedMediaDuration(int64_t aDuration) override;
+
+public:
+  // Returns true if this media supports random seeking. False for example with
+  // chained ogg files.
+  bool IsMediaSeekable();
+  // Returns true if seeking is supported on a transport level (e.g. the server
+  // supports range requests, we are playing a file, etc.).
+  bool IsTransportSeekable();
+
+  // Return the time ranges that can be seeked into.
+  virtual media::TimeIntervals GetSeekable();
+
+  // Set the end time of the media resource. When playback reaches
+  // this point the media pauses. aTime is in seconds.
+  virtual void SetFragmentEndTime(double aTime);
+
+  // Invalidate the frame.
+  void Invalidate();
+  void InvalidateWithFlags(uint32_t aFlags);
+
+  // Suspend any media downloads that are in progress. Called by the
+  // media element when it is sent to the bfcache, or when we need
+  // to throttle the download. Call on the main thread only. This can
+  // be called multiple times, there's an internal "suspend count".
+  virtual void Suspend();
+
+  // Resume any media downloads that have been suspended. Called by the
+  // media element when it is restored from the bfcache, or when we need
+  // to stop throttling the download. Call on the main thread only.
+  // The download will only actually resume once as many Resume calls
+  // have been made as Suspend calls.
+  virtual void Resume();
+
+  // Moves any existing channel loads into or out of background. Background
+  // loads don't block the load event. This is called when we stop or restart
+  // delaying the load event. This also determines whether any new loads
+  // initiated (for example to seek) will be in the background.  This calls
+  // SetLoadInBackground() on mResource.
+  void SetLoadInBackground(bool aLoadInBackground);
+
+  MediaDecoderStateMachine* GetStateMachine() const;
+  void SetStateMachine(MediaDecoderStateMachine* aStateMachine);
+
+  // Constructs the time ranges representing what segments of the media
+  // are buffered and playable.
+  virtual media::TimeIntervals GetBuffered();
+
+  // Returns the size, in bytes, of the heap memory used by the currently
+  // queued decoded video and audio data.
+  size_t SizeOfVideoQueue();
+  size_t SizeOfAudioQueue();
+
+  // Helper struct for accumulating resource sizes that need to be measured
+  // asynchronously. Once all references are dropped the callback will be
+  // invoked.
+  struct ResourceSizes
+  {
+    typedef MozPromise<size_t, size_t, true> SizeOfPromise;
+    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ResourceSizes)
+    explicit ResourceSizes(MallocSizeOf aMallocSizeOf)
+      : mMallocSizeOf(aMallocSizeOf)
+      , mByteSize(0)
+      , mCallback()
+    {
+    }
+
+    mozilla::MallocSizeOf mMallocSizeOf;
+    mozilla::Atomic<size_t> mByteSize;
+
+    RefPtr<SizeOfPromise> Promise()
+    {
+      return mCallback.Ensure(__func__);
+    }
+
+private:
+    ~ResourceSizes()
+    {
+      mCallback.ResolveIfExists(mByteSize, __func__);
+    }
+
+    MozPromiseHolder<SizeOfPromise> mCallback;
+  };
+
+  virtual void AddSizeOfResources(ResourceSizes* aSizes);
+
+  VideoFrameContainer* GetVideoFrameContainer() final override
+  {
+    return mVideoFrameContainer;
+  }
+  layers::ImageContainer* GetImageContainer() override;
+
+  // Fire timeupdate events if needed according to the time constraints
+  // outlined in the specification.
+  void FireTimeUpdate();
+
+  // Something has changed that could affect the computed playback rate,
+  // so recompute it. The monitor must be held.
+  virtual void UpdatePlaybackRate();
+
+  // The actual playback rate computation. The monitor must be held.
+  void ComputePlaybackRate();
+
+  // Returns true if we can play the entire media through without stopping
+  // to buffer, given the current download and playback rates.
+  virtual bool CanPlayThrough();
+
+  void SetAudioChannel(dom::AudioChannel aChannel) { mAudioChannel = aChannel; }
+  dom::AudioChannel GetAudioChannel() { return mAudioChannel; }
+
+  // Called from HTMLMediaElement when owner document activity changes
+  virtual void SetElementVisibility(bool aIsVisible);
+
+  // Force override the visible state to hidden.
+  // Called from HTMLMediaElement when testing of video decode suspend from mochitests.
+  void SetForcedHidden(bool aForcedHidden);
+
+  /******
+   * The following methods must only be called on the main
+   * thread.
+   ******/
+
+  // Change to a new play state. This updates the mState variable and
+  // notifies any thread blocking on this object's monitor of the
+  // change. Call on the main thread only.
+  virtual void ChangeState(PlayState aState);
+
+  // Called from MetadataLoaded(). Creates audio tracks and adds them to its
+  // owner's audio track list, and implies to video tracks respectively.
+  // Call on the main thread only.
+  void ConstructMediaTracks();
+
+  // Removes all audio tracks and video tracks that are previously added into
+  // the track list. Call on the main thread only.
+  void RemoveMediaTracks();
+
+  // Called when the video has completed playing.
+  // Call on the main thread only.
+  void PlaybackEnded();
+
+  void OnSeekRejected();
+  void OnSeekResolved(SeekResolveValue aVal);
+
+  void SeekingChanged()
+  {
+    // Stop updating the bytes downloaded for progress notifications when
+    // seeking to prevent wild changes to the progress notification.
+    MOZ_ASSERT(NS_IsMainThread());
+    mIgnoreProgressData = mLogicallySeeking;
+  }
+
+  // Seeking has started. Inform the element on the main thread.
+  void SeekingStarted();
+
+  void UpdateLogicalPositionInternal();
+  void UpdateLogicalPosition()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(!IsShutdown());
+    // Per spec, offical position remains stable during pause and seek.
+    if (mPlayState == PLAY_STATE_PAUSED || IsSeeking()) {
+      return;
+    }
+    UpdateLogicalPositionInternal();
+  }
+
+  // Find the end of the cached data starting at the current decoder
+  // position.
+  int64_t GetDownloadPosition();
+
+  // Notifies the element that decoding has failed.
+  void DecodeError(const MediaResult& aError);
+
+  // Indicate whether the media is same-origin with the element.
+  void UpdateSameOriginStatus(bool aSameOrigin);
+
+  MediaDecoderOwner* GetOwner() const override;
+
+  typedef MozPromise<RefPtr<CDMProxy>, bool /* aIgnored */, /* IsExclusive = */ true> CDMProxyPromise;
+
+  // Resolved when a CDMProxy is available and the capabilities are known or
+  // rejected when this decoder is about to shut down.
+  RefPtr<CDMProxyPromise> RequestCDMProxy() const;
+
+  void SetCDMProxy(CDMProxy* aProxy);
+
+  void EnsureTelemetryReported();
+
+  static bool IsOggEnabled();
+  static bool IsOpusEnabled();
+  static bool IsWaveEnabled();
+  static bool IsWebMEnabled();
+
+#ifdef MOZ_ANDROID_OMX
+  static bool IsAndroidMediaPluginEnabled();
+#endif
+
+#ifdef MOZ_WMF
+  static bool IsWMFEnabled();
+#endif
+
+  // Return statistics. This is used for progress events and other things.
+  // This can be called from any thread. It's only a snapshot of the
+  // current state, since other threads might be changing the state
+  // at any time.
+  MediaStatistics GetStatistics();
+
+  // Return the frame decode/paint related statistics.
+  FrameStatistics& GetFrameStatistics() { return *mFrameStats; }
+
+  // Increments the parsed and decoded frame counters by the passed in counts.
+  // Can be called on any thread.
+  virtual void NotifyDecodedFrames(const FrameStatisticsData& aStats) override
+  {
+    GetFrameStatistics().NotifyDecodedFrames(aStats);
+  }
+
+  void UpdateReadyState()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(!IsShutdown());
+    mOwner->UpdateReadyState();
+  }
+
+  virtual MediaDecoderOwner::NextFrameStatus NextFrameStatus() { return mNextFrameStatus; }
+  virtual MediaDecoderOwner::NextFrameStatus NextFrameBufferedStatus();
+
+  // Returns a string describing the state of the media player internal
+  // data. Used for debugging purposes.
+  virtual void GetMozDebugReaderData(nsAString& aString) {}
+
+  virtual void DumpDebugInfo();
+
+protected:
+  virtual ~MediaDecoder();
+
+  // Called when the first audio and/or video from the media file has been loaded
+  // by the state machine. Call on the main thread only.
+  virtual void FirstFrameLoaded(nsAutoPtr<MediaInfo> aInfo,
+                                MediaDecoderEventVisibility aEventVisibility);
+
+  void SetStateMachineParameters();
+
+  bool IsShutdown() const;
+
+  // Called by the state machine to notify the decoder that the duration
+  // has changed.
+  void DurationChanged();
+
+  // State-watching manager.
+  WatchManager<MediaDecoder> mWatchManager;
+
+  // Used by the ogg decoder to watch mStateMachineIsShutdown.
+  virtual void ShutdownBitChanged() {}
+
+  double ExplicitDuration() { return mExplicitDuration.Ref().ref(); }
+
+  void SetExplicitDuration(double aValue)
+  {
+    MOZ_ASSERT(!IsShutdown());
+    mExplicitDuration.Set(Some(aValue));
+
+    // We Invoke DurationChanged explicitly, rather than using a watcher, so
+    // that it takes effect immediately, rather than at the end of the current task.
+    DurationChanged();
+  }
+
+  /******
+   * The following members should be accessed with the decoder lock held.
+   ******/
+
+  // The logical playback position of the media resource in units of
+  // seconds. This corresponds to the "official position" in HTML5. Note that
+  // we need to store this as a double, rather than an int64_t (like
+  // mCurrentPosition), so that |v.currentTime = foo; v.currentTime == foo|
+  // returns true without being affected by rounding errors.
+  double mLogicalPosition;
+
+  // The current playback position of the underlying playback infrastructure.
+  // This corresponds to the "current position" in HTML5.
+  // We allow omx subclasses to substitute an alternative current position for
+  // usage with the audio offload player.
+  virtual int64_t CurrentPosition() { return mCurrentPosition; }
+
+  // Official duration of the media resource as observed by script.
+  double mDuration;
+
+  /******
+   * The following member variables can be accessed from any thread.
+   ******/
+
+  // Media data resource.
+  RefPtr<MediaResource> mResource;
+
+  // Amount of buffered data ahead of current time required to consider that
+  // the next frame is available.
+  // An arbitrary value of 250ms is used.
+  static const int DEFAULT_NEXT_FRAME_AVAILABLE_BUFFERED = 250000;
+
+private:
+  // Called when the metadata from the media file has been loaded by the
+  // state machine. Call on the main thread only.
+  void MetadataLoaded(nsAutoPtr<MediaInfo> aInfo,
+                      nsAutoPtr<MetadataTags> aTags,
+                      MediaDecoderEventVisibility aEventVisibility);
+
+  MediaEventSource<void>*
+  DataArrivedEvent() override { return &mDataArrivedEvent; }
+
+  MediaEventSource<RefPtr<layers::KnowsCompositor>>*
+  CompositorUpdatedEvent() override { return &mCompositorUpdatedEvent; }
+
+  void OnPlaybackEvent(MediaEventType aEvent);
+  void OnPlaybackErrorEvent(const MediaResult& aError);
+
+  void OnDecoderDoctorEvent(DecoderDoctorEvent aEvent);
+
+  void OnMediaNotSeekable()
+  {
+    mMediaSeekable = false;
+  }
+
+  void FinishShutdown();
+
+  void ConnectMirrors(MediaDecoderStateMachine* aObject);
+  void DisconnectMirrors();
+
+  MediaEventProducer<void> mDataArrivedEvent;
+  MediaEventProducer<RefPtr<layers::KnowsCompositor>> mCompositorUpdatedEvent;
+
+  // The state machine object for handling the decoding. It is safe to
+  // call methods of this object from other threads. Its internal data
+  // is synchronised on a monitor. The lifetime of this object is
+  // after mPlayState is LOADING and before mPlayState is SHUTDOWN. It
+  // is safe to access it during this period.
+  //
+  // Explicitly prievate to force access via accessors.
+  RefPtr<MediaDecoderStateMachine> mDecoderStateMachine;
+
+  RefPtr<ResourceCallback> mResourceCallback;
+
+  MozPromiseHolder<CDMProxyPromise> mCDMProxyPromiseHolder;
+  RefPtr<CDMProxyPromise> mCDMProxyPromise;
+
+protected:
+  // The promise resolving/rejection is queued as a "micro-task" which will be
+  // handled immediately after the current JS task and before any pending JS
+  // tasks.
+  // At the time we are going to resolve/reject a promise, the "seeking" event
+  // task should already be queued but might yet be processed, so we queue one
+  // more task to file the promise resolving/rejection micro-tasks
+  // asynchronously to make sure that the micro-tasks are processed after the
+  // "seeking" event task.
+  void AsyncResolveSeekDOMPromiseIfExists();
+  void AsyncRejectSeekDOMPromiseIfExists();
+  void DiscardOngoingSeekIfExists();
+  virtual void CallSeek(const SeekTarget& aTarget, dom::Promise* aPromise);
+
+  MozPromiseRequestHolder<SeekPromise> mSeekRequest;
+  RefPtr<dom::Promise> mSeekDOMPromise;
+
+  // True when seeking or otherwise moving the play position around in
+  // such a manner that progress event data is inaccurate. This is set
+  // during seek and duration operations to prevent the progress indicator
+  // from jumping around. Read/Write on the main thread only.
+  bool mIgnoreProgressData;
+
+  // True if the stream is infinite (e.g. a webradio).
+  bool mInfiniteStream;
+
+  // Ensures our media stream has been pinned.
+  void PinForSeek();
+
+  // Ensures our media stream has been unpinned.
+  void UnpinForSeek();
+
+  const char* PlayStateStr();
+
+  void OnMetadataUpdate(TimedMetadata&& aMetadata);
+
+  // This should only ever be accessed from the main thread.
+  // It is set in the constructor and cleared in Shutdown when the element goes
+  // away. The decoder does not add a reference the element.
+  MediaDecoderOwner* mOwner;
+
+  // Counters related to decode and presentation of frames.
+  const RefPtr<FrameStatistics> mFrameStats;
+
+  RefPtr<VideoFrameContainer> mVideoFrameContainer;
+
+  // Data needed to estimate playback data rate. The timeline used for
+  // this estimate is "decode time" (where the "current time" is the
+  // time of the last decoded video frame).
+  RefPtr<MediaChannelStatistics> mPlaybackStatistics;
+
+  // True when our media stream has been pinned. We pin the stream
+  // while seeking.
+  bool mPinnedForSeek;
+
+  // Be assigned from media element during the initialization and pass to
+  // AudioStream Class.
+  dom::AudioChannel mAudioChannel;
+
+  // True if the decoder has been directed to minimize its preroll before
+  // playback starts. After the first time playback starts, we don't attempt
+  // to minimize preroll, as we assume the user is likely to keep playing,
+  // or play the media again.
+  bool mMinimizePreroll;
+
+  // True if audio tracks and video tracks are constructed and added into the
+  // track list, false if all tracks are removed from the track list.
+  bool mMediaTracksConstructed;
+
+  // True if we've already fired metadataloaded.
+  bool mFiredMetadataLoaded;
+
+  // True if the media is seekable (i.e. supports random access).
+  bool mMediaSeekable = true;
+
+  // True if the media is only seekable within its buffered ranges
+  // like WebMs with no cues.
+  bool mMediaSeekableOnlyInBufferedRanges = false;
+
+  // Stores media info, including info of audio tracks and video tracks, should
+  // only be accessed from main thread.
+  nsAutoPtr<MediaInfo> mInfo;
+
+  // Tracks the visiblity status from HTMLMediaElement
+  bool mElementVisible;
+
+  // If true, forces the decoder to be considered hidden.
+  bool mForcedHidden;
+
+  // A listener to receive metadata updates from MDSM.
+  MediaEventListener mTimedMetadataListener;
+
+  MediaEventListener mMetadataLoadedListener;
+  MediaEventListener mFirstFrameLoadedListener;
+
+  MediaEventListener mOnPlaybackEvent;
+  MediaEventListener mOnPlaybackErrorEvent;
+  MediaEventListener mOnDecoderDoctorEvent;
+  MediaEventListener mOnMediaNotSeekable;
+
+protected:
+  // Whether the state machine is shut down.
+  Mirror<bool> mStateMachineIsShutdown;
+
+  // Buffered range, mirrored from the reader.
+  Mirror<media::TimeIntervals> mBuffered;
+
+  // NextFrameStatus, mirrored from the state machine.
+  Mirror<MediaDecoderOwner::NextFrameStatus> mNextFrameStatus;
+
+  // NB: Don't use mCurrentPosition directly, but rather CurrentPosition().
+  Mirror<int64_t> mCurrentPosition;
+
+  // Duration of the media resource according to the state machine.
+  Mirror<media::NullableTimeUnit> mStateMachineDuration;
+
+  // Current playback position in the stream. This is (approximately)
+  // where we're up to playing back the stream. This is not adjusted
+  // during decoder seek operations, but it's updated at the end when we
+  // start playing back again.
+  Mirror<int64_t> mPlaybackPosition;
+
+  // Used to distinguish whether the audio is producing sound.
+  Mirror<bool> mIsAudioDataAudible;
+
+  // Volume of playback.  0.0 = muted. 1.0 = full volume.
+  Canonical<double> mVolume;
+
+  // PlaybackRate and pitch preservation status we should start at.
+  double mPlaybackRate = 1;
+
+  Canonical<bool> mPreservesPitch;
+
+  // Media duration according to the demuxer's current estimate.
+  // Note that it's quite bizarre for this to live on the main thread - it would
+  // make much more sense for this to be owned by the demuxer's task queue. But
+  // currently this is only every changed in NotifyDataArrived, which runs on
+  // the main thread. That will need to be cleaned up at some point.
+  Canonical<media::NullableTimeUnit> mEstimatedDuration;
+
+  // Media duration set explicitly by JS. At present, this is only ever present
+  // for MSE.
+  Canonical<Maybe<double>> mExplicitDuration;
+
+  // Set to one of the valid play states.
+  // This can only be changed on the main thread while holding the decoder
+  // monitor. Thus, it can be safely read while holding the decoder monitor
+  // OR on the main thread.
+  Canonical<PlayState> mPlayState;
+
+  // This can only be changed on the main thread while holding the decoder
+  // monitor. Thus, it can be safely read while holding the decoder monitor
+  // OR on the main thread.
+  Canonical<PlayState> mNextState;
+
+  // True if the decoder is seeking.
+  Canonical<bool> mLogicallySeeking;
+
+  // True if the media is same-origin with the element. Data can only be
+  // passed to MediaStreams when this is true.
+  Canonical<bool> mSameOriginMedia;
+
+  // An identifier for the principal of the media. Used to track when
+  // main-thread induced principal changes get reflected on MSG thread.
+  Canonical<PrincipalHandle> mMediaPrincipalHandle;
+
+  // Estimate of the current playback rate (bytes/second).
+  Canonical<double> mPlaybackBytesPerSecond;
+
+  // True if mPlaybackBytesPerSecond is a reliable estimate.
+  Canonical<bool> mPlaybackRateReliable;
+
+  // Current decoding position in the stream. This is where the decoder
+  // is up to consuming the stream. This is not adjusted during decoder
+  // seek operations, but it's updated at the end when we start playing
+  // back again.
+  Canonical<int64_t> mDecoderPosition;
+
+  // True if the decoder is visible.
+  Canonical<bool> mIsVisible;
+
+public:
+  AbstractCanonical<media::NullableTimeUnit>* CanonicalDurationOrNull() override;
+  AbstractCanonical<double>* CanonicalVolume() {
+    return &mVolume;
+  }
+  AbstractCanonical<bool>* CanonicalPreservesPitch() {
+    return &mPreservesPitch;
+  }
+  AbstractCanonical<media::NullableTimeUnit>* CanonicalEstimatedDuration() {
+    return &mEstimatedDuration;
+  }
+  AbstractCanonical<Maybe<double>>* CanonicalExplicitDuration() {
+    return &mExplicitDuration;
+  }
+  AbstractCanonical<PlayState>* CanonicalPlayState() {
+    return &mPlayState;
+  }
+  AbstractCanonical<PlayState>* CanonicalNextPlayState() {
+    return &mNextState;
+  }
+  AbstractCanonical<bool>* CanonicalLogicallySeeking() {
+    return &mLogicallySeeking;
+  }
+  AbstractCanonical<bool>* CanonicalSameOriginMedia() {
+    return &mSameOriginMedia;
+  }
+  AbstractCanonical<PrincipalHandle>* CanonicalMediaPrincipalHandle() {
+    return &mMediaPrincipalHandle;
+  }
+  AbstractCanonical<double>* CanonicalPlaybackBytesPerSecond() {
+    return &mPlaybackBytesPerSecond;
+  }
+  AbstractCanonical<bool>* CanonicalPlaybackRateReliable() {
+    return &mPlaybackRateReliable;
+  }
+  AbstractCanonical<int64_t>* CanonicalDecoderPosition() {
+    return &mDecoderPosition;
+  }
+  AbstractCanonical<bool>* CanonicalIsVisible() {
+    return &mIsVisible;
+  }
+
+private:
+  // Notify owner when the audible state changed
+  void NotifyAudibleStateChanged();
+
+  /* Functions called by ResourceCallback */
+
+  // A media stream is assumed to be infinite if the metadata doesn't
+  // contain the duration, and range requests are not supported, and
+  // no headers give a hint of a possible duration (Content-Length,
+  // Content-Duration, and variants), and we cannot seek in the media
+  // stream to determine the duration.
+  //
+  // When the media stream ends, we can know the duration, thus the stream is
+  // no longer considered to be infinite.
+  void SetInfinite(bool aInfinite);
+
+  // Called by MediaResource when the principal of the resource has
+  // changed. Called on main thread only.
+  void NotifyPrincipalChanged();
+
+  // Called by MediaResource when the "cache suspended" status changes.
+  // If MediaResource::IsSuspendedByCache returns true, then the decoder
+  // should stop buffering or otherwise waiting for download progress and
+  // start consuming data, if possible, because the cache is full.
+  void NotifySuspendedStatusChanged();
+
+  // Called by the MediaResource to keep track of the number of bytes read
+  // from the resource. Called on the main by an event runner dispatched
+  // by the MediaResource read functions.
+  void NotifyBytesConsumed(int64_t aBytes, int64_t aOffset);
+
+  // Called by nsChannelToPipeListener or MediaResource when the
+  // download has ended. Called on the main thread only. aStatus is
+  // the result from OnStopRequest.
+  void NotifyDownloadEnded(nsresult aStatus);
+
+  bool mTelemetryReported;
+};
+
+} // namespace mozilla
+
+#endif