The Tor Browser: comparison content/media/MediaResource.h

--1:000000000000
+:976c37d67790
+/* 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(MediaResource_h_)
+#define MediaResource_h_
+#include "mozilla/Mutex.h"
+#include "nsIChannel.h"
+#include "nsIURI.h"
+#include "nsIStreamingProtocolController.h"
+#include "nsIStreamListener.h"
+#include "nsIChannelEventSink.h"
+#include "nsIInterfaceRequestor.h"
+#include "MediaCache.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/TimeStamp.h"
+#include "nsThreadUtils.h"
+// For HTTP seeking, if number of bytes needing to be
+// seeked forward is less than this value then a read is
+// done rather than a byte range request.
+static const int64_t SEEK_VS_READ_THRESHOLD = 32*1024;
+static const uint32_t HTTP_REQUESTED_RANGE_NOT_SATISFIABLE_CODE = 416;
+// Number of bytes we have accumulated before we assume the connection download
+// rate can be reliably calculated. 57 Segments at IW=3 allows slow start to
+// reach a CWND of 30 (See bug 831998)
+static const int64_t RELIABLE_DATA_THRESHOLD = 57 * 1460;
+class nsIHttpChannel;
+class nsIPrincipal;
+namespace mozilla {
+class MediaDecoder;
+/**
+* This class is useful for estimating rates of data passing through
+* some channel. The idea is that activity on the channel "starts"
+* and "stops" over time. At certain times data passes through the
+* channel (usually while the channel is active; data passing through
+* an inactive channel is ignored). The GetRate() function computes
+* an estimate of the "current rate" of the channel, which is some
+* kind of average of the data passing through over the time the
+* channel is active.
+*
+* All methods take "now" as a parameter so the user of this class can
+* control the timeline used.
+*/
+class MediaChannelStatistics {
+public:
+MediaChannelStatistics() { Reset(); }
+MediaChannelStatistics(MediaChannelStatistics * aCopyFrom)
+{
+MOZ_ASSERT(aCopyFrom);
+mAccumulatedBytes = aCopyFrom->mAccumulatedBytes;
+mAccumulatedTime = aCopyFrom->mAccumulatedTime;
+mLastStartTime = aCopyFrom->mLastStartTime;
+mIsStarted = aCopyFrom->mIsStarted;
+}
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaChannelStatistics)
+void Reset() {
+mLastStartTime = TimeStamp();
+mAccumulatedTime = TimeDuration(0);
+mAccumulatedBytes = 0;
+mIsStarted = false;
+}
+void Start() {
+if (mIsStarted)
+return;
+mLastStartTime = TimeStamp::Now();
+mIsStarted = true;
+}
+void Stop() {
+if (!mIsStarted)
+return;
+mAccumulatedTime += TimeStamp::Now() - mLastStartTime;
+mIsStarted = false;
+}
+void AddBytes(int64_t aBytes) {
+if (!mIsStarted) {
+// ignore this data, it may be related to seeking or some other
+// operation we don't care about
+return;
+}
+mAccumulatedBytes += aBytes;
+}
+double GetRateAtLastStop(bool* aReliable) {
+double seconds = mAccumulatedTime.ToSeconds();
+*aReliable = (seconds >= 1.0) ||
+(mAccumulatedBytes >= RELIABLE_DATA_THRESHOLD);
+if (seconds <= 0.0)
+return 0.0;
+return static_cast<double>(mAccumulatedBytes)/seconds;
+}
+double GetRate(bool* aReliable) {
+TimeDuration time = mAccumulatedTime;
+if (mIsStarted) {
+time += TimeStamp::Now() - mLastStartTime;
+}
+double seconds = time.ToSeconds();
+*aReliable = (seconds >= 3.0) ||
+(mAccumulatedBytes >= RELIABLE_DATA_THRESHOLD);
+if (seconds <= 0.0)
+return 0.0;
+return static_cast<double>(mAccumulatedBytes)/seconds;
+}
+private:
+int64_t      mAccumulatedBytes;
+TimeDuration mAccumulatedTime;
+TimeStamp    mLastStartTime;
+bool         mIsStarted;
+};
+// Forward declaration for use in MediaByteRange.
+class TimestampedMediaByteRange;
+// Represents a section of contiguous media, with a start and end offset.
+// Used to denote ranges of data which are cached.
+class MediaByteRange {
+public:
+MediaByteRange() : mStart(0), mEnd(0) {}
+MediaByteRange(int64_t aStart, int64_t aEnd)
+: mStart(aStart), mEnd(aEnd)
+{
+NS_ASSERTION(mStart < mEnd, "Range should end after start!");
+}
+MediaByteRange(TimestampedMediaByteRange& aByteRange);
+bool IsNull() const {
+return mStart == 0 && mEnd == 0;
+}
+// Clears byte range values.
+void Clear() {
+mStart = 0;
+mEnd = 0;
+}
+int64_t mStart, mEnd;
+};
+// Represents a section of contiguous media, with a start and end offset, and
+// a timestamp representing the start time.
+class TimestampedMediaByteRange : public MediaByteRange {
+public:
+TimestampedMediaByteRange() : MediaByteRange(), mStartTime(-1) {}
+TimestampedMediaByteRange(int64_t aStart, int64_t aEnd, int64_t aStartTime)
+: MediaByteRange(aStart, aEnd), mStartTime(aStartTime)
+{
+NS_ASSERTION(aStartTime >= 0, "Start time should not be negative!");
+}
+bool IsNull() const {
+return MediaByteRange::IsNull() && mStartTime == -1;
+}
+// Clears byte range values.
+void Clear() {
+MediaByteRange::Clear();
+mStartTime = -1;
+}
+// In usecs.
+int64_t mStartTime;
+};
+inline MediaByteRange::MediaByteRange(TimestampedMediaByteRange& aByteRange)
+: mStart(aByteRange.mStart), mEnd(aByteRange.mEnd)
+{
+NS_ASSERTION(mStart < mEnd, "Range should end after start!");
+}
+class RtspMediaResource;
+/**
+* Provides a thread-safe, seek/read interface to resources
+* loaded from a URI. Uses MediaCache to cache data received over
+* Necko's async channel API, thus resolving the mismatch between clients
+* that need efficient random access to the data and protocols that do not
+* support efficient random access, such as HTTP.
+*
+* Instances of this class must be created on the main thread.
+* Most methods must be called on the main thread only. Read, Seek and
+* Tell must only be called on non-main threads. In the case of the Ogg
+* Decoder they are called on the Decode thread for example. You must
+* ensure that no threads are calling these methods once Close is called.
+*
+* Instances of this class are reference counted. Use nsRefPtr for
+* managing the lifetime of instances of this class.
+*
+* The generic implementation of this class is ChannelMediaResource, which can
+* handle any URI for which Necko supports AsyncOpen.
+* The 'file:' protocol can be implemented efficiently with direct random
+* access, so the FileMediaResource implementation class bypasses the cache.
+* MediaResource::Create automatically chooses the best implementation class.
+*/
+class MediaResource : public nsISupports
+{
+public:
+// Our refcounting is threadsafe, and when our refcount drops to zero
+// we dispatch an event to the main thread to delete the MediaResource.
+// Note that this means it's safe for references to this object to be
+// released on a non main thread, but the destructor will always run on
+// the main thread.
+NS_DECL_THREADSAFE_ISUPPORTS
+// The following can be called on the main thread only:
+// Get the URI
+virtual nsIURI* URI() const { return nullptr; }
+// Close the resource, stop any listeners, channels, etc.
+// Cancels any currently blocking Read request and forces that request to
+// return an error.
+virtual nsresult Close() = 0;
+// Suspend any downloads that are in progress.
+// If aCloseImmediately is set, resources should be released immediately
+// since we don't expect to resume again any time soon. Otherwise we
+// may resume again soon so resources should be held for a little
+// while.
+virtual void Suspend(bool aCloseImmediately) = 0;
+// Resume any downloads that have been suspended.
+virtual void Resume() = 0;
+// Get the current principal for the channel
+virtual already_AddRefed<nsIPrincipal> GetCurrentPrincipal() = 0;
+// If this returns false, then we shouldn't try to clone this MediaResource
+// because its underlying resources are not suitable for reuse (e.g.
+// because the underlying connection has been lost, or this resource
+// just can't be safely cloned). If this returns true, CloneData could
+// still fail. If this returns false, CloneData should not be called.
+virtual bool CanClone() { return false; }
+// Create a new stream of the same type that refers to the same URI
+// with a new channel. Any cached data associated with the original
+// stream should be accessible in the new stream too.
+virtual already_AddRefed<MediaResource> CloneData(MediaDecoder* aDecoder) = 0;
+// Set statistics to be recorded to the object passed in.
+virtual void RecordStatisticsTo(MediaChannelStatistics *aStatistics) { }
+// These methods are called off the main thread.
+// The mode is initially MODE_PLAYBACK.
+virtual void SetReadMode(MediaCacheStream::ReadMode aMode) = 0;
+// This is the client's estimate of the playback rate assuming
+// the media plays continuously. The cache can't guess this itself
+// because it doesn't know when the decoder was paused, buffering, etc.
+virtual void SetPlaybackRate(uint32_t aBytesPerSecond) = 0;
+// Read up to aCount bytes from the stream. The buffer must have
+// enough room for at least aCount bytes. Stores the number of
+// actual bytes read in aBytes (0 on end of file).
+// May read less than aCount bytes if the number of
+// available bytes is less than aCount. Always check *aBytes after
+// read, and call again if necessary.
+virtual nsresult Read(char* aBuffer, uint32_t aCount, uint32_t* aBytes) = 0;
+// Read up to aCount bytes from the stream. The read starts at
+// aOffset in the stream, seeking to that location initially if
+// it is not the current stream offset. The remaining arguments,
+// results and requirements are the same as per the Read method.
+virtual nsresult ReadAt(int64_t aOffset, char* aBuffer,
+uint32_t aCount, uint32_t* aBytes) = 0;
+// Seek to the given bytes offset in the stream. aWhence can be
+// one of:
+//   NS_SEEK_SET
+//   NS_SEEK_CUR
+//   NS_SEEK_END
+//
+// In the Http strategy case the cancel will cause the http
+// channel's listener to close the pipe, forcing an i/o error on any
+// blocked read. This will allow the decode thread to complete the
+// event.
+//
+// In the case of a seek in progress, the byte range request creates
+// a new listener. This is done on the main thread via seek
+// synchronously dispatching an event. This avoids the issue of us
+// closing the listener but an outstanding byte range request
+// creating a new one. They run on the same thread so no explicit
+// synchronisation is required. The byte range request checks for
+// the cancel flag and does not create a new channel or listener if
+// we are cancelling.
+//
+// The default strategy does not do any seeking - the only issue is
+// a blocked read which it handles by causing the listener to close
+// the pipe, as per the http case.
+//
+// The file strategy doesn't block for any great length of time so
+// is fine for a no-op cancel.
+virtual nsresult Seek(int32_t aWhence, int64_t aOffset) = 0;
+virtual void StartSeekingForMetadata() = 0;
+virtual void EndSeekingForMetadata() = 0;
+// Report the current offset in bytes from the start of the stream.
+virtual int64_t Tell() = 0;
+// Moves any existing channel loads into the background, so that they don't
+// block the load event. Any new loads initiated (for example to seek)
+// will also be in the background.
+virtual void MoveLoadsToBackground() {}
+// Ensures that the value returned by IsSuspendedByCache below is up to date
+// (i.e. the cache has examined this stream at least once).
+virtual void EnsureCacheUpToDate() {}
+// These can be called on any thread.
+// Cached blocks associated with this stream will not be evicted
+// while the stream is pinned.
+virtual void Pin() = 0;
+virtual void Unpin() = 0;
+// Get the estimated download rate in bytes per second (assuming no
+// pausing of the channel is requested by Gecko).
+// *aIsReliable is set to true if we think the estimate is useful.
+virtual double GetDownloadRate(bool* aIsReliable) = 0;
+// Get the length of the stream in bytes. Returns -1 if not known.
+// This can change over time; after a seek operation, a misbehaving
+// server may give us a resource of a different length to what it had
+// reported previously --- or it may just lie in its Content-Length
+// header and give us more or less data than it reported. We will adjust
+// the result of GetLength to reflect the data that's actually arriving.
+virtual int64_t GetLength() = 0;
+// Returns the offset of the first byte of cached data at or after aOffset,
+// or -1 if there is no such cached data.
+virtual int64_t GetNextCachedData(int64_t aOffset) = 0;
+// Returns the end of the bytes starting at the given offset
+// which are in cache.
+virtual int64_t GetCachedDataEnd(int64_t aOffset) = 0;
+// Returns true if all the data from aOffset to the end of the stream
+// is in cache. If the end of the stream is not known, we return false.
+virtual bool IsDataCachedToEndOfResource(int64_t aOffset) = 0;
+// Returns true if this stream is suspended by the cache because the
+// cache is full. If true then the decoder should try to start consuming
+// data, otherwise we may not be able to make progress.
+// MediaDecoder::NotifySuspendedStatusChanged is called when this
+// changes.
+// For resources using the media cache, this returns true only when all
+// streams for the same resource are all suspended.
+virtual bool IsSuspendedByCache() = 0;
+// Returns true if this stream has been suspended.
+virtual bool IsSuspended() = 0;
+// Reads only data which is cached in the media cache. If you try to read
+// any data which overlaps uncached data, or if aCount bytes otherwise can't
+// be read, this function will return failure. This function be called from
+// any thread, and it is the only read operation which is safe to call on
+// the main thread, since it's guaranteed to be non blocking.
+virtual nsresult ReadFromCache(char* aBuffer,
+int64_t aOffset,
+uint32_t aCount) = 0;
+// Returns true if the resource can be seeked to unbuffered ranges, i.e.
+// for an HTTP network stream this returns true if HTTP1.1 Byte Range
+// requests are supported by the connection/server.
+virtual bool IsTransportSeekable() = 0;
+/**
+* Create a resource, reading data from the channel. Call on main thread only.
+* The caller must follow up by calling resource->Open().
+*/
+static already_AddRefed<MediaResource> Create(MediaDecoder* aDecoder, nsIChannel* aChannel);
+/**
+* Open the stream. This creates a stream listener and returns it in
+* aStreamListener; this listener needs to be notified of incoming data.
+*/
+virtual nsresult Open(nsIStreamListener** aStreamListener) = 0;
+/**
+* Fills aRanges with MediaByteRanges representing the data which is cached
+* in the media cache. Stream should be pinned during call and while
+* aRanges is being used.
+*/
+virtual nsresult GetCachedRanges(nsTArray<MediaByteRange>& aRanges) = 0;
+// Ensure that the media cache writes any data held in its partial block.
+// Called on the main thread only.
+virtual void FlushCache() { }
+// Notify that the last data byte range was loaded.
+virtual void NotifyLastByteRange() { }
+// Returns the content type of the resource. This is copied from the
+// nsIChannel when the MediaResource is created. Safe to call from
+// any thread.
+virtual const nsCString& GetContentType() const = 0;
+// Get the RtspMediaResource pointer if this MediaResource really is a
+// RtspMediaResource. For calling Rtsp specific functions.
+virtual RtspMediaResource* GetRtspPointer() {
+return nullptr;
+}
+// Return true if the stream is a live stream
+virtual bool IsRealTime() {
+return false;
+}
+virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+return 0;
+}
+virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+protected:
+virtual ~MediaResource() {};
+private:
+void Destroy();
+};
+class BaseMediaResource : public MediaResource {
+public:
+virtual nsIURI* URI() const { return mURI; }
+virtual void MoveLoadsToBackground();
+virtual size_t SizeOfExcludingThis(
+MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
+{
+// Might be useful to track in the future:
+// - mChannel
+// - mURI (possibly owned, looks like just a ref from mChannel)
+// Not owned:
+// - mDecoder
+size_t size = MediaResource::SizeOfExcludingThis(aMallocSizeOf);
+size += mContentType.SizeOfIncludingThisIfUnshared(aMallocSizeOf);
+return size;
+}
+virtual size_t SizeOfIncludingThis(
+MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE
+{
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+protected:
+BaseMediaResource(MediaDecoder* aDecoder,
+nsIChannel* aChannel,
+nsIURI* aURI,
+const nsACString& aContentType) :
+mDecoder(aDecoder),
+mChannel(aChannel),
+mURI(aURI),
+mContentType(aContentType),
+mLoadInBackground(false)
+{
+MOZ_COUNT_CTOR(BaseMediaResource);
+NS_ASSERTION(!mContentType.IsEmpty(), "Must know content type");
+}
+virtual ~BaseMediaResource()
+{
+MOZ_COUNT_DTOR(BaseMediaResource);
+}
+virtual const nsCString& GetContentType() const MOZ_OVERRIDE
+{
+return mContentType;
+}
+// Set the request's load flags to aFlags.  If the request is part of a
+// load group, the request is removed from the group, the flags are set, and
+// then the request is added back to the load group.
+void ModifyLoadFlags(nsLoadFlags aFlags);
+// Dispatches an event to call MediaDecoder::NotifyBytesConsumed(aNumBytes, aOffset)
+// on the main thread. This is called automatically after every read.
+void DispatchBytesConsumed(int64_t aNumBytes, int64_t aOffset);
+// This is not an nsCOMPointer to prevent a circular reference
+// between the decoder to the media stream object. The stream never
+// outlives the lifetime of the decoder.
+MediaDecoder* mDecoder;
+// Channel used to download the media data. Must be accessed
+// from the main thread only.
+nsCOMPtr<nsIChannel> mChannel;
+// URI in case the stream needs to be re-opened. Access from
+// main thread only.
+nsCOMPtr<nsIURI> mURI;
+// Content-Type of the channel. This is copied from the nsIChannel when the
+// MediaResource is created. This is constant, so accessing from any thread
+// is safe.
+const nsAutoCString mContentType;
+// True if MoveLoadsToBackground() has been called, i.e. the load event
+// has been fired, and all channel loads will be in the background.
+bool mLoadInBackground;
+};
+/**
+* This is the MediaResource implementation that wraps Necko channels.
+* Much of its functionality is actually delegated to MediaCache via
+* an underlying MediaCacheStream.
+*
+* All synchronization is performed by MediaCacheStream; all off-main-
+* thread operations are delegated directly to that object.
+*/
+class ChannelMediaResource : public BaseMediaResource
+{
+public:
+ChannelMediaResource(MediaDecoder* aDecoder,
+nsIChannel* aChannel,
+nsIURI* aURI,
+const nsACString& aContentType);
+~ChannelMediaResource();
+// These are called on the main thread by MediaCache. These must
+// not block or grab locks, because the media cache is holding its lock.
+// Notify that data is available from the cache. This can happen even
+// if this stream didn't read any data, since another stream might have
+// received data for the same resource.
+void CacheClientNotifyDataReceived();
+// Notify that we reached the end of the stream. This can happen even
+// if this stream didn't read any data, since another stream might have
+// received data for the same resource.
+void CacheClientNotifyDataEnded(nsresult aStatus);
+// Notify that the principal for the cached resource changed.
+void CacheClientNotifyPrincipalChanged();
+// These are called on the main thread by MediaCache. These shouldn't block,
+// but they may grab locks --- the media cache is not holding its lock
+// when these are called.
+// Start a new load at the given aOffset. The old load is cancelled
+// and no more data from the old load will be notified via
+// MediaCacheStream::NotifyDataReceived/Ended.
+// This can fail.
+nsresult CacheClientSeek(int64_t aOffset, bool aResume);
+// Suspend the current load since data is currently not wanted
+nsresult CacheClientSuspend();
+// Resume the current load since data is wanted again
+nsresult CacheClientResume();
+// Ensure that the media cache writes any data held in its partial block.
+// Called on the main thread.
+virtual void FlushCache() MOZ_OVERRIDE;
+// Notify that the last data byte range was loaded.
+virtual void NotifyLastByteRange() MOZ_OVERRIDE;
+// Main thread
+virtual nsresult Open(nsIStreamListener** aStreamListener);
+virtual nsresult Close();
+virtual void     Suspend(bool aCloseImmediately);
+virtual void     Resume();
+virtual already_AddRefed<nsIPrincipal> GetCurrentPrincipal();
+// Return true if the stream has been closed.
+bool IsClosed() const { return mCacheStream.IsClosed(); }
+virtual bool     CanClone();
+virtual already_AddRefed<MediaResource> CloneData(MediaDecoder* aDecoder);
+// Set statistics to be recorded to the object passed in. If not called,
+// |ChannelMediaResource| will create it's own statistics objects in |Open|.
+void RecordStatisticsTo(MediaChannelStatistics *aStatistics) MOZ_OVERRIDE {
+NS_ASSERTION(aStatistics, "Statistics param cannot be null!");
+MutexAutoLock lock(mLock);
+if (!mChannelStatistics) {
+mChannelStatistics = aStatistics;
+}
+}
+virtual nsresult ReadFromCache(char* aBuffer, int64_t aOffset, uint32_t aCount);
+virtual void     EnsureCacheUpToDate();
+// Other thread
+virtual void     SetReadMode(MediaCacheStream::ReadMode aMode);
+virtual void     SetPlaybackRate(uint32_t aBytesPerSecond);
+virtual nsresult Read(char* aBuffer, uint32_t aCount, uint32_t* aBytes);
+virtual nsresult ReadAt(int64_t offset, char* aBuffer,
+uint32_t aCount, uint32_t* aBytes);
+virtual nsresult Seek(int32_t aWhence, int64_t aOffset);
+virtual void     StartSeekingForMetadata();
+virtual void     EndSeekingForMetadata();
+virtual int64_t  Tell();
+// Any thread
+virtual void    Pin();
+virtual void    Unpin();
+virtual double  GetDownloadRate(bool* aIsReliable);
+virtual int64_t GetLength();
+virtual int64_t GetNextCachedData(int64_t aOffset);
+virtual int64_t GetCachedDataEnd(int64_t aOffset);
+virtual bool    IsDataCachedToEndOfResource(int64_t aOffset);
+virtual bool    IsSuspendedByCache();
+virtual bool    IsSuspended();
+virtual bool    IsTransportSeekable() MOZ_OVERRIDE;
+virtual size_t SizeOfExcludingThis(
+MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE {
+// Might be useful to track in the future:
+//   - mListener (seems minor)
+//   - mChannelStatistics (seems minor)
+//     owned if RecordStatisticsTo is not called
+//   - mDataReceivedEvent (seems minor)
+size_t size = BaseMediaResource::SizeOfExcludingThis(aMallocSizeOf);
+size += mCacheStream.SizeOfExcludingThis(aMallocSizeOf);
+return size;
+}
+virtual size_t SizeOfIncludingThis(
+MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE {
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+class Listener MOZ_FINAL : public nsIStreamListener,
+public nsIInterfaceRequestor,
+public nsIChannelEventSink
+{
+public:
+Listener(ChannelMediaResource* aResource) : mResource(aResource) {}
+~Listener() {}
+NS_DECL_ISUPPORTS
+NS_DECL_NSIREQUESTOBSERVER
+NS_DECL_NSISTREAMLISTENER
+NS_DECL_NSICHANNELEVENTSINK
+NS_DECL_NSIINTERFACEREQUESTOR
+void Revoke() { mResource = nullptr; }
+private:
+nsRefPtr<ChannelMediaResource> mResource;
+};
+friend class Listener;
+nsresult GetCachedRanges(nsTArray<MediaByteRange>& aRanges);
+protected:
+// These are called on the main thread by Listener.
+nsresult OnStartRequest(nsIRequest* aRequest);
+nsresult OnStopRequest(nsIRequest* aRequest, nsresult aStatus);
+nsresult OnDataAvailable(nsIRequest* aRequest,
+nsIInputStream* aStream,
+uint32_t aCount);
+nsresult OnChannelRedirect(nsIChannel* aOld, nsIChannel* aNew, uint32_t aFlags);
+// Opens the channel, using an HTTP byte range request to start at mOffset
+// if possible. Main thread only.
+nsresult OpenChannel(nsIStreamListener** aStreamListener);
+nsresult RecreateChannel();
+// Add headers to HTTP request. Main thread only.
+void SetupChannelHeaders();
+// Closes the channel. Main thread only.
+void CloseChannel();
+// Parses 'Content-Range' header and returns results via parameters.
+// Returns error if header is not available, values are not parse-able or
+// values are out of range.
+nsresult ParseContentRangeHeader(nsIHttpChannel * aHttpChan,
+int64_t& aRangeStart,
+int64_t& aRangeEnd,
+int64_t& aRangeTotal);
+void DoNotifyDataReceived();
+static NS_METHOD CopySegmentToCache(nsIInputStream *aInStream,
+void *aClosure,
+const char *aFromSegment,
+uint32_t aToOffset,
+uint32_t aCount,
+uint32_t *aWriteCount);
+// Suspend the channel only if the channels is currently downloading data.
+// If it isn't we set a flag, mIgnoreResume, so that PossiblyResume knows
+// whether to acutually resume or not.
+void PossiblySuspend();
+// Resume from a suspend if we actually suspended (See PossiblySuspend).
+void PossiblyResume();
+// Main thread access only
+int64_t            mOffset;
+nsRefPtr<Listener> mListener;
+// A data received event for the decoder that has been dispatched but has
+// not yet been processed.
+nsRevocableEventPtr<nsRunnableMethod<ChannelMediaResource, void, false> > mDataReceivedEvent;
+uint32_t           mSuspendCount;
+// When this flag is set, if we get a network error we should silently
+// reopen the stream.
+bool               mReopenOnError;
+// When this flag is set, we should not report the next close of the
+// channel.
+bool               mIgnoreClose;
+// Any thread access
+MediaCacheStream mCacheStream;
+// This lock protects mChannelStatistics
+Mutex               mLock;
+nsRefPtr<MediaChannelStatistics> mChannelStatistics;
+// True if we couldn't suspend the stream and we therefore don't want
+// to resume later. This is usually due to the channel not being in the
+// isPending state at the time of the suspend request.
+bool mIgnoreResume;
+// True if we are seeking to get the real duration of the file.
+bool mSeekingForMetadata;
+// Start and end offset of the bytes to be requested.
+MediaByteRange mByteRange;
+// True if the stream can seek into unbuffered ranged, i.e. if the
+// connection supports byte range requests.
+bool mIsTransportSeekable;
+};
+} // namespace mozilla
+#endif

The Tor Browser / file comparison

comparison: content/media/MediaResource.h

content/media/MediaResource.h