2008-10-19 07:39:21 +00:00
|
|
|
/* vim:set ts=2 sw=2 sts=2 et cindent: */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2009-04-01 00:52:56 +00:00
|
|
|
|
2012-02-15 04:35:01 +00:00
|
|
|
#if !defined(MediaResource_h_)
|
|
|
|
#define MediaResource_h_
|
2008-10-19 07:39:21 +00:00
|
|
|
|
Rollup of bug 645263 and bug 646259: Switch to mozilla:: sync primitives. r=cjones,dbaron,doublec,ehsan src=bsmedberg
Bug 645263, part 0: Count sync primitive ctor/dtors. r=dbaron
Bug 645263, part 1: Migrate content/media to mozilla:: sync primitives. r=doublec
Bug 645263, part 2: Migrate modules/plugin to mozilla:: sync primitives. sr=bsmedberg
Bug 645263, part 3: Migrate nsComponentManagerImpl to mozilla:: sync primitives. sr=bsmedberg
Bug 645263, part 4: Migrate everything else to mozilla:: sync primitives. r=dbaron
Bug 645263, part 5: Remove nsAutoLock.*. sr=bsmedberg
Bug 645263, part 6: Make editor test be nicer to deadlock detector. r=ehsan
Bug 645263, part 7: Disable tracemalloc backtraces for xpcshell tests. r=dbaron
Bug 646259: Fix nsCacheService to use a CondVar for notifying. r=cjones
2011-04-01 04:29:02 +00:00
|
|
|
#include "mozilla/Mutex.h"
|
2009-05-18 18:15:05 +00:00
|
|
|
#include "mozilla/XPCOM.h"
|
2012-09-29 23:29:04 +00:00
|
|
|
#include "mozilla/ReentrantMonitor.h"
|
2008-10-19 07:39:21 +00:00
|
|
|
#include "nsIChannel.h"
|
2012-09-29 23:29:04 +00:00
|
|
|
#include "nsIHttpChannel.h"
|
2008-10-19 07:39:21 +00:00
|
|
|
#include "nsIPrincipal.h"
|
|
|
|
#include "nsIURI.h"
|
2009-01-24 11:00:17 +00:00
|
|
|
#include "nsIStreamListener.h"
|
2009-05-13 21:52:50 +00:00
|
|
|
#include "nsIChannelEventSink.h"
|
|
|
|
#include "nsIInterfaceRequestor.h"
|
2012-11-14 19:46:40 +00:00
|
|
|
#include "MediaCache.h"
|
2012-06-19 02:30:09 +00:00
|
|
|
#include "mozilla/Attributes.h"
|
2008-10-19 07:39:21 +00:00
|
|
|
|
2009-01-16 08:22:08 +00:00
|
|
|
// 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.
|
2012-08-22 15:56:38 +00:00
|
|
|
static const int64_t SEEK_VS_READ_THRESHOLD = 32*1024;
|
2009-01-16 08:22:08 +00:00
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
static const uint32_t HTTP_REQUESTED_RANGE_NOT_SATISFIABLE_CODE = 416;
|
2009-12-15 20:08:59 +00:00
|
|
|
|
2012-02-15 04:35:01 +00:00
|
|
|
namespace mozilla {
|
|
|
|
|
2012-11-14 19:46:40 +00:00
|
|
|
class MediaDecoder;
|
2012-11-14 19:45:33 +00:00
|
|
|
|
2009-04-01 00:52:56 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*
|
2009-04-11 09:39:24 +00:00
|
|
|
* All methods take "now" as a parameter so the user of this class can
|
|
|
|
* control the timeline used.
|
2009-04-01 00:52:56 +00:00
|
|
|
*/
|
2012-02-15 04:35:01 +00:00
|
|
|
class MediaChannelStatistics {
|
2009-04-01 00:52:56 +00:00
|
|
|
public:
|
2012-02-15 04:35:01 +00:00
|
|
|
MediaChannelStatistics() { Reset(); }
|
2012-12-13 19:42:45 +00:00
|
|
|
|
2013-01-23 19:24:41 +00:00
|
|
|
MediaChannelStatistics(MediaChannelStatistics * aCopyFrom)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(aCopyFrom);
|
|
|
|
*this = *aCopyFrom;
|
|
|
|
}
|
|
|
|
|
2012-12-13 19:42:45 +00:00
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaChannelStatistics)
|
|
|
|
|
2009-04-01 00:52:56 +00:00
|
|
|
void Reset() {
|
2009-04-11 09:39:24 +00:00
|
|
|
mLastStartTime = TimeStamp();
|
|
|
|
mAccumulatedTime = TimeDuration(0);
|
2009-04-01 00:52:56 +00:00
|
|
|
mAccumulatedBytes = 0;
|
2011-09-29 23:34:37 +00:00
|
|
|
mIsStarted = false;
|
2009-04-01 00:52:56 +00:00
|
|
|
}
|
2012-12-13 19:42:45 +00:00
|
|
|
void Start() {
|
2009-04-01 00:52:56 +00:00
|
|
|
if (mIsStarted)
|
|
|
|
return;
|
2012-12-13 19:42:45 +00:00
|
|
|
mLastStartTime = TimeStamp::Now();
|
2011-09-29 23:34:37 +00:00
|
|
|
mIsStarted = true;
|
2009-04-01 00:52:56 +00:00
|
|
|
}
|
2012-12-13 19:42:45 +00:00
|
|
|
void Stop() {
|
2009-04-01 00:52:56 +00:00
|
|
|
if (!mIsStarted)
|
|
|
|
return;
|
2012-12-13 19:42:45 +00:00
|
|
|
mAccumulatedTime += TimeStamp::Now() - mLastStartTime;
|
2011-09-29 23:34:37 +00:00
|
|
|
mIsStarted = false;
|
2009-04-01 00:52:56 +00:00
|
|
|
}
|
2012-08-22 15:56:38 +00:00
|
|
|
void AddBytes(int64_t aBytes) {
|
2009-04-01 00:52:56 +00:00
|
|
|
if (!mIsStarted) {
|
|
|
|
// ignore this data, it may be related to seeking or some other
|
|
|
|
// operation we don't care about
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
mAccumulatedBytes += aBytes;
|
|
|
|
}
|
2011-09-29 06:19:26 +00:00
|
|
|
double GetRateAtLastStop(bool* aReliable) {
|
2009-04-11 09:39:24 +00:00
|
|
|
double seconds = mAccumulatedTime.ToSeconds();
|
|
|
|
*aReliable = seconds >= 1.0;
|
|
|
|
if (seconds <= 0.0)
|
|
|
|
return 0.0;
|
2011-04-13 22:12:23 +00:00
|
|
|
return static_cast<double>(mAccumulatedBytes)/seconds;
|
2009-04-01 00:52:56 +00:00
|
|
|
}
|
2012-12-13 19:42:45 +00:00
|
|
|
double GetRate(bool* aReliable) {
|
2009-04-11 09:39:24 +00:00
|
|
|
TimeDuration time = mAccumulatedTime;
|
2009-04-01 00:52:56 +00:00
|
|
|
if (mIsStarted) {
|
2012-12-13 19:42:45 +00:00
|
|
|
time += TimeStamp::Now() - mLastStartTime;
|
2009-04-01 00:52:56 +00:00
|
|
|
}
|
2009-04-11 09:39:24 +00:00
|
|
|
double seconds = time.ToSeconds();
|
2009-05-19 05:14:20 +00:00
|
|
|
*aReliable = seconds >= 3.0;
|
2009-04-11 09:39:24 +00:00
|
|
|
if (seconds <= 0.0)
|
2009-04-01 00:52:56 +00:00
|
|
|
return 0.0;
|
2011-04-13 22:12:23 +00:00
|
|
|
return static_cast<double>(mAccumulatedBytes)/seconds;
|
2009-04-01 00:52:56 +00:00
|
|
|
}
|
|
|
|
private:
|
2012-08-22 15:56:38 +00:00
|
|
|
int64_t mAccumulatedBytes;
|
2009-04-11 09:39:24 +00:00
|
|
|
TimeDuration mAccumulatedTime;
|
|
|
|
TimeStamp mLastStartTime;
|
2012-02-15 04:35:01 +00:00
|
|
|
bool mIsStarted;
|
2009-04-01 00:52:56 +00:00
|
|
|
};
|
|
|
|
|
2012-12-13 19:42:45 +00:00
|
|
|
// Forward declaration for use in MediaByteRange.
|
|
|
|
class TimestampedMediaByteRange;
|
|
|
|
|
2011-03-23 22:28:58 +00:00
|
|
|
// Represents a section of contiguous media, with a start and end offset.
|
|
|
|
// Used to denote ranges of data which are cached.
|
2012-02-15 04:35:01 +00:00
|
|
|
class MediaByteRange {
|
2011-03-23 22:28:58 +00:00
|
|
|
public:
|
2012-02-15 04:35:01 +00:00
|
|
|
MediaByteRange() : mStart(0), mEnd(0) {}
|
2011-03-23 22:28:58 +00:00
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
MediaByteRange(int64_t aStart, int64_t aEnd)
|
2011-03-23 22:28:58 +00:00
|
|
|
: mStart(aStart), mEnd(aEnd)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(mStart < mEnd, "Range should end after start!");
|
|
|
|
}
|
|
|
|
|
2012-12-13 19:42:45 +00:00
|
|
|
MediaByteRange(TimestampedMediaByteRange& aByteRange);
|
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
bool IsNull() const {
|
2011-03-23 22:28:58 +00:00
|
|
|
return mStart == 0 && mEnd == 0;
|
|
|
|
}
|
|
|
|
|
2012-09-29 23:29:04 +00:00
|
|
|
// Clears byte range values.
|
|
|
|
void Clear() {
|
|
|
|
mStart = 0;
|
|
|
|
mEnd = 0;
|
|
|
|
}
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
int64_t mStart, mEnd;
|
2011-03-23 22:28:58 +00:00
|
|
|
};
|
|
|
|
|
2012-12-13 19:42:45 +00:00
|
|
|
// 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!");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-15 04:35:01 +00:00
|
|
|
/**
|
|
|
|
* Provides a thread-safe, seek/read interface to resources
|
2012-11-14 19:46:40 +00:00
|
|
|
* loaded from a URI. Uses MediaCache to cache data received over
|
2012-02-15 04:35:01 +00:00
|
|
|
* 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 explicitly managed. 'delete' it when done.
|
|
|
|
*
|
|
|
|
* 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
|
2008-10-19 07:39:21 +00:00
|
|
|
{
|
2009-03-30 01:19:10 +00:00
|
|
|
public:
|
2013-02-04 21:34:23 +00:00
|
|
|
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaResource)
|
|
|
|
|
2009-04-01 00:52:56 +00:00
|
|
|
// The following can be called on the main thread only:
|
2009-09-15 02:28:08 +00:00
|
|
|
// Get the URI
|
2012-11-17 04:31:53 +00:00
|
|
|
virtual nsIURI* URI() const { return nullptr; }
|
2012-02-15 04:35:01 +00:00
|
|
|
// Close the resource, stop any listeners, channels, etc.
|
2009-04-01 00:52:56 +00:00
|
|
|
// Cancels any currently blocking Read request and forces that request to
|
|
|
|
// return an error.
|
2009-03-30 01:19:10 +00:00
|
|
|
virtual nsresult Close() = 0;
|
2009-04-01 00:52:56 +00:00
|
|
|
// Suspend any downloads that are in progress.
|
2009-05-18 02:02:20 +00:00
|
|
|
// 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.
|
2011-09-29 06:19:26 +00:00
|
|
|
virtual void Suspend(bool aCloseImmediately) = 0;
|
2009-04-01 00:52:56 +00:00
|
|
|
// Resume any downloads that have been suspended.
|
|
|
|
virtual void Resume() = 0;
|
2009-05-13 21:52:50 +00:00
|
|
|
// Get the current principal for the channel
|
|
|
|
virtual already_AddRefed<nsIPrincipal> GetCurrentPrincipal() = 0;
|
2012-03-20 07:55:40 +00:00
|
|
|
// 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; }
|
2009-09-15 02:30:44 +00:00
|
|
|
// 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.
|
2013-05-02 22:59:18 +00:00
|
|
|
virtual already_AddRefed<MediaResource> CloneData(MediaDecoder* aDecoder) = 0;
|
2012-12-13 19:42:45 +00:00
|
|
|
// Set statistics to be recorded to the object passed in.
|
|
|
|
virtual void RecordStatisticsTo(MediaChannelStatistics *aStatistics) { }
|
2009-04-01 00:52:56 +00:00
|
|
|
|
|
|
|
// These methods are called off the main thread.
|
|
|
|
// The mode is initially MODE_PLAYBACK.
|
2012-11-14 19:46:40 +00:00
|
|
|
virtual void SetReadMode(MediaCacheStream::ReadMode aMode) = 0;
|
2009-04-01 00:52:56 +00:00
|
|
|
// 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.
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual void SetPlaybackRate(uint32_t aBytesPerSecond) = 0;
|
2008-10-19 07:39:21 +00:00
|
|
|
// Read up to aCount bytes from the stream. The buffer must have
|
|
|
|
// enough room for at least aCount bytes. Stores the number of
|
2009-04-01 00:52:56 +00:00
|
|
|
// actual bytes read in aBytes (0 on end of file).
|
|
|
|
// May read less than aCount bytes if the number of
|
2008-10-23 08:14:28 +00:00
|
|
|
// available bytes is less than aCount. Always check *aBytes after
|
|
|
|
// read, and call again if necessary.
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual nsresult Read(char* aBuffer, uint32_t aCount, uint32_t* aBytes) = 0;
|
2008-10-19 07:39:21 +00:00
|
|
|
// Seek to the given bytes offset in the stream. aWhence can be
|
|
|
|
// one of:
|
|
|
|
// NS_SEEK_SET
|
|
|
|
// NS_SEEK_CUR
|
|
|
|
// NS_SEEK_END
|
|
|
|
//
|
2009-03-30 01:19:10 +00:00
|
|
|
// 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.
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual nsresult Seek(int32_t aWhence, int64_t aOffset) = 0;
|
2012-08-17 17:01:08 +00:00
|
|
|
virtual void StartSeekingForMetadata() = 0;
|
|
|
|
virtual void EndSeekingForMetadata() = 0;
|
2008-10-19 07:39:21 +00:00
|
|
|
// Report the current offset in bytes from the start of the stream.
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual int64_t Tell() = 0;
|
2009-04-10 01:28:24 +00:00
|
|
|
// 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.
|
2012-11-17 04:31:53 +00:00
|
|
|
virtual void MoveLoadsToBackground() {}
|
2011-11-30 05:05:49 +00:00
|
|
|
// 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() {}
|
2009-03-30 01:19:10 +00:00
|
|
|
|
2009-04-01 00:52:56 +00:00
|
|
|
// 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.
|
2011-09-29 06:19:26 +00:00
|
|
|
virtual double GetDownloadRate(bool* aIsReliable) = 0;
|
2009-04-01 00:52:56 +00:00
|
|
|
// 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.
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual int64_t GetLength() = 0;
|
2009-05-17 22:15:57 +00:00
|
|
|
// Returns the offset of the first byte of cached data at or after aOffset,
|
|
|
|
// or -1 if there is no such cached data.
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual int64_t GetNextCachedData(int64_t aOffset) = 0;
|
2009-04-01 00:52:56 +00:00
|
|
|
// Returns the end of the bytes starting at the given offset
|
|
|
|
// which are in cache.
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual int64_t GetCachedDataEnd(int64_t aOffset) = 0;
|
2009-04-01 00:52:56 +00:00
|
|
|
// 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.
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual bool IsDataCachedToEndOfResource(int64_t aOffset) = 0;
|
2009-04-01 00:52:56 +00:00
|
|
|
// 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.
|
2012-11-14 19:46:40 +00:00
|
|
|
// MediaDecoder::NotifySuspendedStatusChanged is called when this
|
2009-04-01 00:52:56 +00:00
|
|
|
// changes.
|
2011-11-30 05:05:49 +00:00
|
|
|
// For resources using the media cache, this returns true only when all
|
|
|
|
// streams for the same resource are all suspended.
|
2013-05-02 22:59:18 +00:00
|
|
|
virtual bool IsSuspendedByCache() = 0;
|
2010-08-13 00:41:47 +00:00
|
|
|
// Returns true if this stream has been suspended.
|
2011-09-29 06:19:26 +00:00
|
|
|
virtual bool IsSuspended() = 0;
|
2010-08-05 07:40:35 +00:00
|
|
|
// 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,
|
2012-08-22 15:56:38 +00:00
|
|
|
int64_t aOffset,
|
|
|
|
uint32_t aCount) = 0;
|
2013-02-04 21:34:23 +00:00
|
|
|
// 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;
|
2009-03-30 01:19:10 +00:00
|
|
|
|
|
|
|
/**
|
2012-02-15 04:35:01 +00:00
|
|
|
* Create a resource, reading data from the channel. Call on main thread only.
|
|
|
|
* The caller must follow up by calling resource->Open().
|
2009-03-30 01:19:10 +00:00
|
|
|
*/
|
2013-05-02 22:59:18 +00:00
|
|
|
static already_AddRefed<MediaResource> Create(MediaDecoder* aDecoder, nsIChannel* aChannel);
|
2009-09-15 02:30:43 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
2009-01-21 23:54:40 +00:00
|
|
|
|
2013-04-03 00:05:00 +00:00
|
|
|
#ifdef MOZ_DASH
|
2012-09-29 23:29:04 +00:00
|
|
|
/**
|
|
|
|
* Open the stream using a specific byte range only. Creates a stream
|
|
|
|
* listener and returns it in aStreamListener; this listener needs to be
|
|
|
|
* notified of incoming data. Byte range is specified in aByteRange.
|
|
|
|
*/
|
|
|
|
virtual nsresult OpenByteRange(nsIStreamListener** aStreamListener,
|
|
|
|
MediaByteRange const &aByteRange)
|
|
|
|
{
|
|
|
|
return Open(aStreamListener);
|
|
|
|
}
|
2013-04-03 00:05:00 +00:00
|
|
|
#endif
|
2012-09-29 23:29:04 +00:00
|
|
|
|
2011-03-23 22:28:58 +00:00
|
|
|
/**
|
2012-02-15 04:35:01 +00:00
|
|
|
* Fills aRanges with MediaByteRanges representing the data which is cached
|
2011-03-23 22:28:58 +00:00
|
|
|
* in the media cache. Stream should be pinned during call and while
|
|
|
|
* aRanges is being used.
|
|
|
|
*/
|
2012-02-15 04:35:01 +00:00
|
|
|
virtual nsresult GetCachedRanges(nsTArray<MediaByteRange>& aRanges) = 0;
|
2012-12-06 23:27:08 +00:00
|
|
|
|
|
|
|
// 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() { }
|
2013-02-15 01:10:58 +00:00
|
|
|
|
|
|
|
// Returns the content type of the resource. This is copied from the
|
|
|
|
// nsIChannel when the MediaResource is created. Safe to call from
|
|
|
|
// any thread.
|
2013-02-26 11:02:20 +00:00
|
|
|
virtual const nsCString& GetContentType() const = 0;
|
2013-05-02 22:59:18 +00:00
|
|
|
protected:
|
|
|
|
virtual ~MediaResource() {};
|
2012-11-17 04:31:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
class BaseMediaResource : public MediaResource {
|
|
|
|
public:
|
|
|
|
virtual nsIURI* URI() const { return mURI; }
|
|
|
|
virtual void MoveLoadsToBackground();
|
2011-03-23 22:28:58 +00:00
|
|
|
|
2009-03-30 01:19:10 +00:00
|
|
|
protected:
|
2013-02-15 01:10:58 +00:00
|
|
|
BaseMediaResource(MediaDecoder* aDecoder,
|
|
|
|
nsIChannel* aChannel,
|
|
|
|
nsIURI* aURI,
|
|
|
|
const nsACString& aContentType) :
|
2009-03-30 01:19:10 +00:00
|
|
|
mDecoder(aDecoder),
|
|
|
|
mChannel(aChannel),
|
2009-04-10 01:28:24 +00:00
|
|
|
mURI(aURI),
|
2013-02-15 01:10:58 +00:00
|
|
|
mContentType(aContentType),
|
2011-09-29 23:34:37 +00:00
|
|
|
mLoadInBackground(false)
|
2009-03-30 01:19:10 +00:00
|
|
|
{
|
2012-11-17 04:31:53 +00:00
|
|
|
MOZ_COUNT_CTOR(BaseMediaResource);
|
2013-02-15 01:10:58 +00:00
|
|
|
NS_ASSERTION(!mContentType.IsEmpty(), "Must know content type");
|
2012-11-17 04:31:53 +00:00
|
|
|
}
|
|
|
|
virtual ~BaseMediaResource()
|
|
|
|
{
|
|
|
|
MOZ_COUNT_DTOR(BaseMediaResource);
|
2009-03-30 01:19:10 +00:00
|
|
|
}
|
|
|
|
|
2013-02-26 11:02:20 +00:00
|
|
|
virtual const nsCString& GetContentType() const MOZ_OVERRIDE
|
2013-02-15 01:10:58 +00:00
|
|
|
{
|
|
|
|
return mContentType;
|
|
|
|
}
|
|
|
|
|
2011-02-14 23:21:32 +00:00
|
|
|
// 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);
|
|
|
|
|
2009-03-30 01:19:10 +00:00
|
|
|
// 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.
|
2012-11-14 19:46:40 +00:00
|
|
|
MediaDecoder* mDecoder;
|
2009-03-30 01:19:10 +00:00
|
|
|
|
|
|
|
// 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;
|
2009-04-10 01:28:24 +00:00
|
|
|
|
2013-02-15 01:10:58 +00:00
|
|
|
// 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;
|
|
|
|
|
2011-09-29 23:34:37 +00:00
|
|
|
// True if MoveLoadsToBackground() has been called, i.e. the load event
|
2009-04-10 01:28:24 +00:00
|
|
|
// has been fired, and all channel loads will be in the background.
|
2011-09-29 06:19:26 +00:00
|
|
|
bool mLoadInBackground;
|
2009-04-01 00:52:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2012-02-15 04:35:01 +00:00
|
|
|
* This is the MediaResource implementation that wraps Necko channels.
|
2012-11-14 19:46:40 +00:00
|
|
|
* Much of its functionality is actually delegated to MediaCache via
|
|
|
|
* an underlying MediaCacheStream.
|
2009-04-01 00:52:56 +00:00
|
|
|
*
|
2012-11-14 19:46:40 +00:00
|
|
|
* All synchronization is performed by MediaCacheStream; all off-main-
|
2009-04-01 00:52:56 +00:00
|
|
|
* thread operations are delegated directly to that object.
|
|
|
|
*/
|
2012-11-17 04:31:53 +00:00
|
|
|
class ChannelMediaResource : public BaseMediaResource
|
2009-04-01 00:52:56 +00:00
|
|
|
{
|
|
|
|
public:
|
2013-02-15 01:10:58 +00:00
|
|
|
ChannelMediaResource(MediaDecoder* aDecoder,
|
|
|
|
nsIChannel* aChannel,
|
|
|
|
nsIURI* aURI,
|
|
|
|
const nsACString& aContentType);
|
2012-02-15 04:35:01 +00:00
|
|
|
~ChannelMediaResource();
|
2009-04-01 00:52:56 +00:00
|
|
|
|
2012-11-14 19:46:40 +00:00
|
|
|
// These are called on the main thread by MediaCache. These must
|
2009-10-09 11:46:23 +00:00
|
|
|
// not block or grab locks, because the media cache is holding its lock.
|
2009-09-15 02:30:45 +00:00
|
|
|
// 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);
|
2012-04-30 03:12:42 +00:00
|
|
|
// Notify that the principal for the cached resource changed.
|
|
|
|
void CacheClientNotifyPrincipalChanged();
|
2009-10-09 11:46:23 +00:00
|
|
|
|
2012-11-14 19:46:40 +00:00
|
|
|
// These are called on the main thread by MediaCache. These shouldn't block,
|
2009-10-09 11:46:23 +00:00
|
|
|
// but they may grab locks --- the media cache is not holding its lock
|
|
|
|
// when these are called.
|
2009-04-01 00:52:56 +00:00
|
|
|
// 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
|
2012-11-14 19:46:40 +00:00
|
|
|
// MediaCacheStream::NotifyDataReceived/Ended.
|
2009-04-01 00:52:56 +00:00
|
|
|
// This can fail.
|
2012-08-22 15:56:38 +00:00
|
|
|
nsresult CacheClientSeek(int64_t aOffset, bool aResume);
|
2009-04-01 00:52:56 +00:00
|
|
|
// Suspend the current load since data is currently not wanted
|
|
|
|
nsresult CacheClientSuspend();
|
|
|
|
// Resume the current load since data is wanted again
|
|
|
|
nsresult CacheClientResume();
|
|
|
|
|
2012-12-06 23:27:08 +00:00
|
|
|
// 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;
|
|
|
|
|
2009-04-01 00:52:56 +00:00
|
|
|
// Main thread
|
|
|
|
virtual nsresult Open(nsIStreamListener** aStreamListener);
|
2013-04-03 00:05:00 +00:00
|
|
|
#ifdef MOZ_DASH
|
2012-09-29 23:29:04 +00:00
|
|
|
virtual nsresult OpenByteRange(nsIStreamListener** aStreamListener,
|
|
|
|
MediaByteRange const & aByteRange);
|
2013-04-03 00:05:00 +00:00
|
|
|
#endif
|
2009-04-01 00:52:56 +00:00
|
|
|
virtual nsresult Close();
|
2011-09-29 06:19:26 +00:00
|
|
|
virtual void Suspend(bool aCloseImmediately);
|
2009-04-01 00:52:56 +00:00
|
|
|
virtual void Resume();
|
2009-05-13 21:52:50 +00:00
|
|
|
virtual already_AddRefed<nsIPrincipal> GetCurrentPrincipal();
|
2011-09-29 23:34:37 +00:00
|
|
|
// Return true if the stream has been closed.
|
2011-09-29 06:19:26 +00:00
|
|
|
bool IsClosed() const { return mCacheStream.IsClosed(); }
|
2012-03-20 07:55:40 +00:00
|
|
|
virtual bool CanClone();
|
2013-05-02 22:59:18 +00:00
|
|
|
virtual already_AddRefed<MediaResource> CloneData(MediaDecoder* aDecoder);
|
2012-12-13 19:42:45 +00:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
}
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual nsresult ReadFromCache(char* aBuffer, int64_t aOffset, uint32_t aCount);
|
2011-11-30 05:05:49 +00:00
|
|
|
virtual void EnsureCacheUpToDate();
|
2009-04-01 00:52:56 +00:00
|
|
|
|
|
|
|
// Other thread
|
2012-11-14 19:46:40 +00:00
|
|
|
virtual void SetReadMode(MediaCacheStream::ReadMode aMode);
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual void SetPlaybackRate(uint32_t aBytesPerSecond);
|
|
|
|
virtual nsresult Read(char* aBuffer, uint32_t aCount, uint32_t* aBytes);
|
|
|
|
virtual nsresult Seek(int32_t aWhence, int64_t aOffset);
|
2012-08-17 17:01:08 +00:00
|
|
|
virtual void StartSeekingForMetadata();
|
|
|
|
virtual void EndSeekingForMetadata();
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual int64_t Tell();
|
2009-04-01 00:52:56 +00:00
|
|
|
|
|
|
|
// Any thread
|
|
|
|
virtual void Pin();
|
|
|
|
virtual void Unpin();
|
2011-09-29 06:19:26 +00:00
|
|
|
virtual double GetDownloadRate(bool* aIsReliable);
|
2012-08-22 15:56:38 +00:00
|
|
|
virtual int64_t GetLength();
|
|
|
|
virtual int64_t GetNextCachedData(int64_t aOffset);
|
|
|
|
virtual int64_t GetCachedDataEnd(int64_t aOffset);
|
|
|
|
virtual bool IsDataCachedToEndOfResource(int64_t aOffset);
|
2013-05-02 22:59:18 +00:00
|
|
|
virtual bool IsSuspendedByCache();
|
2011-09-29 06:19:26 +00:00
|
|
|
virtual bool IsSuspended();
|
2013-02-04 21:34:23 +00:00
|
|
|
virtual bool IsTransportSeekable() MOZ_OVERRIDE;
|
2009-04-01 00:52:56 +00:00
|
|
|
|
2012-06-19 02:30:09 +00:00
|
|
|
class Listener MOZ_FINAL : public nsIStreamListener,
|
|
|
|
public nsIInterfaceRequestor,
|
|
|
|
public nsIChannelEventSink
|
2009-05-13 21:52:50 +00:00
|
|
|
{
|
2009-04-01 00:52:56 +00:00
|
|
|
public:
|
2012-02-15 04:35:01 +00:00
|
|
|
Listener(ChannelMediaResource* aResource) : mResource(aResource) {}
|
2012-12-13 19:42:45 +00:00
|
|
|
~Listener() {}
|
2009-04-01 00:52:56 +00:00
|
|
|
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
NS_DECL_NSIREQUESTOBSERVER
|
|
|
|
NS_DECL_NSISTREAMLISTENER
|
2009-05-13 21:52:50 +00:00
|
|
|
NS_DECL_NSICHANNELEVENTSINK
|
|
|
|
NS_DECL_NSIINTERFACEREQUESTOR
|
2009-04-01 00:52:56 +00:00
|
|
|
|
2012-07-30 14:20:58 +00:00
|
|
|
void Revoke() { mResource = nullptr; }
|
2009-04-01 00:52:56 +00:00
|
|
|
|
|
|
|
private:
|
2013-05-02 22:59:18 +00:00
|
|
|
nsRefPtr<ChannelMediaResource> mResource;
|
2009-04-01 00:52:56 +00:00
|
|
|
};
|
|
|
|
friend class Listener;
|
|
|
|
|
2012-02-15 04:35:01 +00:00
|
|
|
nsresult GetCachedRanges(nsTArray<MediaByteRange>& aRanges);
|
2011-03-23 22:28:58 +00:00
|
|
|
|
2009-09-15 02:30:45 +00:00
|
|
|
protected:
|
2009-04-01 00:52:56 +00:00
|
|
|
// 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,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aCount);
|
|
|
|
nsresult OnChannelRedirect(nsIChannel* aOld, nsIChannel* aNew, uint32_t aFlags);
|
2009-04-01 00:52:56 +00:00
|
|
|
|
2009-05-18 02:02:20 +00:00
|
|
|
// Opens the channel, using an HTTP byte range request to start at mOffset
|
2009-04-01 00:52:56 +00:00
|
|
|
// if possible. Main thread only.
|
2009-05-18 02:02:20 +00:00
|
|
|
nsresult OpenChannel(nsIStreamListener** aStreamListener);
|
2009-09-15 02:30:44 +00:00
|
|
|
nsresult RecreateChannel();
|
2010-07-29 04:58:07 +00:00
|
|
|
// Add headers to HTTP request. Main thread only.
|
2009-05-13 21:52:50 +00:00
|
|
|
void SetupChannelHeaders();
|
2009-04-01 00:52:56 +00:00
|
|
|
// Closes the channel. Main thread only.
|
|
|
|
void CloseChannel();
|
|
|
|
|
2012-09-29 23:29:04 +00:00
|
|
|
// 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);
|
|
|
|
|
2009-09-15 02:30:45 +00:00
|
|
|
void DoNotifyDataReceived();
|
|
|
|
|
2009-04-01 00:52:56 +00:00
|
|
|
static NS_METHOD CopySegmentToCache(nsIInputStream *aInStream,
|
|
|
|
void *aClosure,
|
|
|
|
const char *aFromSegment,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aToOffset,
|
|
|
|
uint32_t aCount,
|
|
|
|
uint32_t *aWriteCount);
|
2009-04-01 00:52:56 +00:00
|
|
|
|
2011-04-01 09:43:29 +00:00
|
|
|
// 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();
|
|
|
|
|
2009-04-01 00:52:56 +00:00
|
|
|
// Main thread access only
|
2012-08-22 15:56:38 +00:00
|
|
|
int64_t mOffset;
|
2009-04-01 00:52:56 +00:00
|
|
|
nsRefPtr<Listener> mListener;
|
2009-09-15 02:30:45 +00:00
|
|
|
// A data received event for the decoder that has been dispatched but has
|
|
|
|
// not yet been processed.
|
2012-02-15 04:35:01 +00:00
|
|
|
nsRevocableEventPtr<nsRunnableMethod<ChannelMediaResource, void, false> > mDataReceivedEvent;
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t mSuspendCount;
|
2009-05-18 02:02:20 +00:00
|
|
|
// When this flag is set, if we get a network error we should silently
|
|
|
|
// reopen the stream.
|
2011-09-29 06:19:26 +00:00
|
|
|
bool mReopenOnError;
|
2009-05-18 02:02:20 +00:00
|
|
|
// When this flag is set, we should not report the next close of the
|
|
|
|
// channel.
|
2011-09-29 06:19:26 +00:00
|
|
|
bool mIgnoreClose;
|
2009-04-01 00:52:56 +00:00
|
|
|
|
|
|
|
// Any thread access
|
2012-11-14 19:46:40 +00:00
|
|
|
MediaCacheStream mCacheStream;
|
2009-03-30 01:19:10 +00:00
|
|
|
|
2011-11-30 05:05:49 +00:00
|
|
|
// This lock protects mChannelStatistics
|
Rollup of bug 645263 and bug 646259: Switch to mozilla:: sync primitives. r=cjones,dbaron,doublec,ehsan src=bsmedberg
Bug 645263, part 0: Count sync primitive ctor/dtors. r=dbaron
Bug 645263, part 1: Migrate content/media to mozilla:: sync primitives. r=doublec
Bug 645263, part 2: Migrate modules/plugin to mozilla:: sync primitives. sr=bsmedberg
Bug 645263, part 3: Migrate nsComponentManagerImpl to mozilla:: sync primitives. sr=bsmedberg
Bug 645263, part 4: Migrate everything else to mozilla:: sync primitives. r=dbaron
Bug 645263, part 5: Remove nsAutoLock.*. sr=bsmedberg
Bug 645263, part 6: Make editor test be nicer to deadlock detector. r=ehsan
Bug 645263, part 7: Disable tracemalloc backtraces for xpcshell tests. r=dbaron
Bug 646259: Fix nsCacheService to use a CondVar for notifying. r=cjones
2011-04-01 04:29:02 +00:00
|
|
|
Mutex mLock;
|
2012-12-13 19:42:45 +00:00
|
|
|
nsRefPtr<MediaChannelStatistics> mChannelStatistics;
|
2011-04-01 09:43:29 +00:00
|
|
|
|
2011-09-29 23:34:37 +00:00
|
|
|
// True if we couldn't suspend the stream and we therefore don't want
|
2011-04-01 09:43:29 +00:00
|
|
|
// to resume later. This is usually due to the channel not being in the
|
|
|
|
// isPending state at the time of the suspend request.
|
2011-09-29 06:19:26 +00:00
|
|
|
bool mIgnoreResume;
|
2012-08-17 17:01:08 +00:00
|
|
|
|
|
|
|
// True if we are seeking to get the real duration of the file.
|
|
|
|
bool mSeekingForMetadata;
|
2012-09-29 23:29:04 +00:00
|
|
|
|
|
|
|
// Start and end offset of the bytes to be requested.
|
|
|
|
MediaByteRange mByteRange;
|
|
|
|
|
2013-04-03 00:05:00 +00:00
|
|
|
#ifdef MOZ_DASH
|
2012-09-29 23:29:04 +00:00
|
|
|
// True if resource was opened with a byte rage request.
|
|
|
|
bool mByteRangeDownloads;
|
|
|
|
|
|
|
|
// Set to false once first byte range request has been made.
|
|
|
|
bool mByteRangeFirstOpen;
|
|
|
|
|
|
|
|
// For byte range requests, set to the offset requested in |Seek|.
|
|
|
|
// Used in |CacheClientSeek| to find the originally requested byte range.
|
|
|
|
// Read/Write on multiple threads; use |mSeekMonitor|.
|
|
|
|
ReentrantMonitor mSeekOffsetMonitor;
|
|
|
|
int64_t mSeekOffset;
|
2013-04-03 00:05:00 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// True if the stream can seek into unbuffered ranged, i.e. if the
|
|
|
|
// connection supports byte range requests.
|
|
|
|
bool mIsTransportSeekable;
|
2008-10-19 07:39:21 +00:00
|
|
|
};
|
|
|
|
|
2012-11-14 19:45:33 +00:00
|
|
|
} // namespace mozilla
|
2012-02-15 04:35:01 +00:00
|
|
|
|
2008-10-19 07:39:21 +00:00
|
|
|
#endif
|