Add m-esr52 at 52.6.0

1 files changed, 1648 insertions, 0 deletions

diff --git a/dom/media/MediaResource.cpp b/dom/media/MediaResource.cpp
new file mode 100644
index 000000000..d36783be7
--- /dev/null
+++ b/dom/media/MediaResource.cpp
@@ -0,0 +1,1648 @@
+/* -*- 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/. */
+
+#include "mozilla/DebugOnly.h"
+
+#include "MediaResource.h"
+#include "MediaResourceCallback.h"
+
+#include "mozilla/Mutex.h"
+#include "nsDebug.h"
+#include "nsNetUtil.h"
+#include "nsThreadUtils.h"
+#include "nsIFile.h"
+#include "nsIFileChannel.h"
+#include "nsIFileStreams.h"
+#include "nsIHttpChannel.h"
+#include "nsISeekableStream.h"
+#include "nsIInputStream.h"
+#include "nsIRequestObserver.h"
+#include "nsIStreamListener.h"
+#include "nsIScriptSecurityManager.h"
+#include "mozilla/dom/HTMLMediaElement.h"
+#include "nsError.h"
+#include "nsICachingChannel.h"
+#include "nsIAsyncVerifyRedirectCallback.h"
+#include "nsContentUtils.h"
+#include "nsHostObjectProtocolHandler.h"
+#include <algorithm>
+#include "nsProxyRelease.h"
+#include "nsIContentPolicy.h"
+
+using mozilla::media::TimeUnit;
+
+mozilla::LazyLogModule gMediaResourceLog("MediaResource");
+#define RESOURCE_LOG(msg, ...) MOZ_LOG(gMediaResourceLog, mozilla::LogLevel::Debug, \
+                                      (msg, ##__VA_ARGS__))
+// Debug logging macro with object pointer and class name.
+#define CMLOG(msg, ...) \
+        RESOURCE_LOG("%p [ChannelMediaResource]: " msg, this, ##__VA_ARGS__)
+
+static const uint32_t HTTP_OK_CODE = 200;
+static const uint32_t HTTP_PARTIAL_RESPONSE_CODE = 206;
+
+namespace mozilla {
+
+void
+MediaResource::Destroy()
+{
+  // Ensures we only delete the MediaResource on the main thread.
+  if (NS_IsMainThread()) {
+    delete this;
+    return;
+  }
+  MOZ_ALWAYS_SUCCEEDS(
+    NS_DispatchToMainThread(NewNonOwningRunnableMethod(this, &MediaResource::Destroy)));
+}
+
+NS_IMPL_ADDREF(MediaResource)
+NS_IMPL_RELEASE_WITH_DESTROY(MediaResource, Destroy())
+NS_IMPL_QUERY_INTERFACE0(MediaResource)
+
+ChannelMediaResource::ChannelMediaResource(MediaResourceCallback* aCallback,
+                                           nsIChannel* aChannel,
+                                           nsIURI* aURI,
+                                           const nsACString& aContentType)
+  : BaseMediaResource(aCallback, aChannel, aURI, aContentType),
+    mOffset(0),
+    mReopenOnError(false),
+    mIgnoreClose(false),
+    mCacheStream(this),
+    mLock("ChannelMediaResource.mLock"),
+    mIgnoreResume(false),
+    mSuspendAgent(mChannel)
+{
+}
+
+ChannelMediaResource::~ChannelMediaResource()
+{
+  if (mListener) {
+    // Kill its reference to us since we're going away
+    mListener->Revoke();
+  }
+}
+
+// ChannelMediaResource::Listener just observes the channel and
+// forwards notifications to the ChannelMediaResource. We use multiple
+// listener objects so that when we open a new stream for a seek we can
+// disconnect the old listener from the ChannelMediaResource and hook up
+// a new listener, so notifications from the old channel are discarded
+// and don't confuse us.
+NS_IMPL_ISUPPORTS(ChannelMediaResource::Listener,
+                  nsIRequestObserver, nsIStreamListener, nsIChannelEventSink,
+                  nsIInterfaceRequestor)
+
+nsresult
+ChannelMediaResource::Listener::OnStartRequest(nsIRequest* aRequest,
+                                               nsISupports* aContext)
+{
+  if (!mResource)
+    return NS_OK;
+  return mResource->OnStartRequest(aRequest);
+}
+
+nsresult
+ChannelMediaResource::Listener::OnStopRequest(nsIRequest* aRequest,
+                                              nsISupports* aContext,
+                                              nsresult aStatus)
+{
+  if (!mResource)
+    return NS_OK;
+  return mResource->OnStopRequest(aRequest, aStatus);
+}
+
+nsresult
+ChannelMediaResource::Listener::OnDataAvailable(nsIRequest* aRequest,
+                                                nsISupports* aContext,
+                                                nsIInputStream* aStream,
+                                                uint64_t aOffset,
+                                                uint32_t aCount)
+{
+  if (!mResource)
+    return NS_OK;
+  return mResource->OnDataAvailable(aRequest, aStream, aCount);
+}
+
+nsresult
+ChannelMediaResource::Listener::AsyncOnChannelRedirect(nsIChannel* aOldChannel,
+                                                       nsIChannel* aNewChannel,
+                                                       uint32_t aFlags,
+                                                       nsIAsyncVerifyRedirectCallback* cb)
+{
+  nsresult rv = NS_OK;
+  if (mResource)
+    rv = mResource->OnChannelRedirect(aOldChannel, aNewChannel, aFlags);
+
+  if (NS_FAILED(rv))
+    return rv;
+
+  cb->OnRedirectVerifyCallback(NS_OK);
+  return NS_OK;
+}
+
+nsresult
+ChannelMediaResource::Listener::GetInterface(const nsIID & aIID, void **aResult)
+{
+  return QueryInterface(aIID, aResult);
+}
+
+nsresult
+ChannelMediaResource::OnStartRequest(nsIRequest* aRequest)
+{
+  NS_ASSERTION(mChannel.get() == aRequest, "Wrong channel!");
+
+  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+  NS_ENSURE_TRUE(owner, NS_ERROR_FAILURE);
+  dom::HTMLMediaElement* element = owner->GetMediaElement();
+  NS_ENSURE_TRUE(element, NS_ERROR_FAILURE);
+  nsresult status;
+  nsresult rv = aRequest->GetStatus(&status);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (status == NS_BINDING_ABORTED) {
+    // Request was aborted before we had a chance to receive any data, or
+    // even an OnStartRequest(). Close the channel. This is important, as
+    // we don't want to mess up our state, as if we're cloned that would
+    // cause the clone to copy incorrect metadata (like whether we're
+    // infinite for example).
+    CloseChannel();
+    return status;
+  }
+
+  if (element->ShouldCheckAllowOrigin()) {
+    // If the request was cancelled by nsCORSListenerProxy due to failing
+    // the CORS security check, send an error through to the media element.
+    if (status == NS_ERROR_DOM_BAD_URI) {
+      mCallback->NotifyNetworkError();
+      return NS_ERROR_DOM_BAD_URI;
+    }
+  }
+
+  nsCOMPtr<nsIHttpChannel> hc = do_QueryInterface(aRequest);
+  bool seekable = false;
+  if (hc) {
+    uint32_t responseStatus = 0;
+    hc->GetResponseStatus(&responseStatus);
+    bool succeeded = false;
+    hc->GetRequestSucceeded(&succeeded);
+
+    if (!succeeded && NS_SUCCEEDED(status)) {
+      // HTTP-level error (e.g. 4xx); treat this as a fatal network-level error.
+      // We might get this on a seek.
+      // (Note that lower-level errors indicated by NS_FAILED(status) are
+      // handled in OnStopRequest.)
+      // A 416 error should treated as EOF here... it's possible
+      // that we don't get Content-Length, we read N bytes, then we
+      // suspend and resume, the resume reopens the channel and we seek to
+      // offset N, but there are no more bytes, so we get a 416
+      // "Requested Range Not Satisfiable".
+      if (responseStatus == HTTP_REQUESTED_RANGE_NOT_SATISFIABLE_CODE) {
+        // OnStopRequest will not be fired, so we need to do some of its
+        // work here.
+        mCacheStream.NotifyDataEnded(status);
+      } else {
+        mCallback->NotifyNetworkError();
+      }
+
+      // This disconnects our listener so we don't get any more data. We
+      // certainly don't want an error page to end up in our cache!
+      CloseChannel();
+      return NS_OK;
+    }
+
+    nsAutoCString ranges;
+    hc->GetResponseHeader(NS_LITERAL_CSTRING("Accept-Ranges"),
+                          ranges);
+    bool acceptsRanges = ranges.EqualsLiteral("bytes");
+    // True if this channel will not return an unbounded amount of data
+    bool dataIsBounded = false;
+
+    int64_t contentLength = -1;
+    hc->GetContentLength(&contentLength);
+    if (contentLength >= 0 &&
+        (responseStatus == HTTP_OK_CODE ||
+         responseStatus == HTTP_PARTIAL_RESPONSE_CODE)) {
+      // "OK" status means Content-Length is for the whole resource.
+      // Since that's bounded, we know we have a finite-length resource.
+      dataIsBounded = true;
+    }
+
+    // Assume Range requests have a bounded upper limit unless the
+    // Content-Range header tells us otherwise.
+    bool boundedSeekLimit = true;
+    // Check response code for byte-range requests (seeking, chunk requests).
+    if (responseStatus == HTTP_PARTIAL_RESPONSE_CODE) {
+      // Parse Content-Range header.
+      int64_t rangeStart = 0;
+      int64_t rangeEnd = 0;
+      int64_t rangeTotal = 0;
+      rv = ParseContentRangeHeader(hc, rangeStart, rangeEnd, rangeTotal);
+
+      // We received 'Content-Range', so the server accepts range requests.
+      bool gotRangeHeader = NS_SUCCEEDED(rv);
+
+      if (gotRangeHeader) {
+        // We received 'Content-Range', so the server accepts range requests.
+        // Notify media cache about the length and start offset of data received.
+        // Note: If aRangeTotal == -1, then the total bytes is unknown at this stage.
+        //       For now, tell the decoder that the stream is infinite.
+        if (rangeTotal == -1) {
+          boundedSeekLimit = false;
+        } else {
+          contentLength = std::max(contentLength, rangeTotal);
+        }
+        // Give some warnings if the ranges are unexpected.
+        // XXX These could be error conditions.
+        NS_WARNING_ASSERTION(
+          mOffset == rangeStart,
+          "response range start does not match current offset");
+        mOffset = rangeStart;
+        mCacheStream.NotifyDataStarted(rangeStart);
+      }
+      acceptsRanges = gotRangeHeader;
+    } else if (mOffset > 0 && responseStatus == HTTP_OK_CODE) {
+      // If we get an OK response but we were seeking, or requesting a byte
+      // range, then we have to assume that seeking doesn't work. We also need
+      // to tell the cache that it's getting data for the start of the stream.
+      mCacheStream.NotifyDataStarted(0);
+      mOffset = 0;
+
+      // The server claimed it supported range requests.  It lied.
+      acceptsRanges = false;
+    }
+    if (mOffset == 0 && contentLength >= 0 &&
+        (responseStatus == HTTP_OK_CODE ||
+         responseStatus == HTTP_PARTIAL_RESPONSE_CODE)) {
+      mCacheStream.NotifyDataLength(contentLength);
+    }
+    // XXX we probably should examine the Content-Range header in case
+    // the server gave us a range which is not quite what we asked for
+
+    // If we get an HTTP_OK_CODE response to our byte range request,
+    // and the server isn't sending Accept-Ranges:bytes then we don't
+    // support seeking.
+    seekable = acceptsRanges;
+    if (seekable && boundedSeekLimit) {
+      // If range requests are supported, and we did not see an unbounded
+      // upper range limit, we assume the resource is bounded.
+      dataIsBounded = true;
+    }
+
+    mCallback->SetInfinite(!dataIsBounded);
+  }
+  mCacheStream.SetTransportSeekable(seekable);
+
+  {
+    MutexAutoLock lock(mLock);
+    mChannelStatistics->Start();
+  }
+
+  mReopenOnError = false;
+  mIgnoreClose = false;
+
+  mSuspendAgent.UpdateSuspendedStatusIfNeeded();
+
+  // Fires an initial progress event.
+  owner->DownloadProgressed();
+
+  return NS_OK;
+}
+
+bool
+ChannelMediaResource::IsTransportSeekable()
+{
+  return mCacheStream.IsTransportSeekable();
+}
+
+nsresult
+ChannelMediaResource::ParseContentRangeHeader(nsIHttpChannel * aHttpChan,
+                                              int64_t& aRangeStart,
+                                              int64_t& aRangeEnd,
+                                              int64_t& aRangeTotal)
+{
+  NS_ENSURE_ARG(aHttpChan);
+
+  nsAutoCString rangeStr;
+  nsresult rv = aHttpChan->GetResponseHeader(NS_LITERAL_CSTRING("Content-Range"),
+                                             rangeStr);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_FALSE(rangeStr.IsEmpty(), NS_ERROR_ILLEGAL_VALUE);
+
+  // Parse the range header: e.g. Content-Range: bytes 7000-7999/8000.
+  int32_t spacePos = rangeStr.Find(NS_LITERAL_CSTRING(" "));
+  int32_t dashPos = rangeStr.Find(NS_LITERAL_CSTRING("-"), true, spacePos);
+  int32_t slashPos = rangeStr.Find(NS_LITERAL_CSTRING("/"), true, dashPos);
+
+  nsAutoCString aRangeStartText;
+  rangeStr.Mid(aRangeStartText, spacePos+1, dashPos-(spacePos+1));
+  aRangeStart = aRangeStartText.ToInteger64(&rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(0 <= aRangeStart, NS_ERROR_ILLEGAL_VALUE);
+
+  nsAutoCString aRangeEndText;
+  rangeStr.Mid(aRangeEndText, dashPos+1, slashPos-(dashPos+1));
+  aRangeEnd = aRangeEndText.ToInteger64(&rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(aRangeStart < aRangeEnd, NS_ERROR_ILLEGAL_VALUE);
+
+  nsAutoCString aRangeTotalText;
+  rangeStr.Right(aRangeTotalText, rangeStr.Length()-(slashPos+1));
+  if (aRangeTotalText[0] == '*') {
+    aRangeTotal = -1;
+  } else {
+    aRangeTotal = aRangeTotalText.ToInteger64(&rv);
+    NS_ENSURE_TRUE(aRangeEnd < aRangeTotal, NS_ERROR_ILLEGAL_VALUE);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  CMLOG("Received bytes [%lld] to [%lld] of [%lld] for decoder[%p]",
+        aRangeStart, aRangeEnd, aRangeTotal, mCallback.get());
+
+  return NS_OK;
+}
+
+nsresult
+ChannelMediaResource::OnStopRequest(nsIRequest* aRequest, nsresult aStatus)
+{
+  NS_ASSERTION(mChannel.get() == aRequest, "Wrong channel!");
+  NS_ASSERTION(!mSuspendAgent.IsSuspended(),
+               "How can OnStopRequest fire while we're suspended?");
+
+  {
+    MutexAutoLock lock(mLock);
+    mChannelStatistics->Stop();
+  }
+
+  // Note that aStatus might have succeeded --- this might be a normal close
+  // --- even in situations where the server cut us off because we were
+  // suspended. So we need to "reopen on error" in that case too. The only
+  // cases where we don't need to reopen are when *we* closed the stream.
+  // But don't reopen if we need to seek and we don't think we can... that would
+  // cause us to just re-read the stream, which would be really bad.
+  if (mReopenOnError &&
+      aStatus != NS_ERROR_PARSED_DATA_CACHED && aStatus != NS_BINDING_ABORTED &&
+      (mOffset == 0 || mCacheStream.IsTransportSeekable())) {
+    // If the stream did close normally, then if the server is seekable we'll
+    // just seek to the end of the resource and get an HTTP 416 error because
+    // there's nothing there, so this isn't bad.
+    nsresult rv = CacheClientSeek(mOffset, false);
+    if (NS_SUCCEEDED(rv))
+      return rv;
+    // If the reopen/reseek fails, just fall through and treat this
+    // error as fatal.
+  }
+
+  if (!mIgnoreClose) {
+    mCacheStream.NotifyDataEnded(aStatus);
+
+    // Move this request back into the foreground.  This is necessary for
+    // requests owned by video documents to ensure the load group fires
+    // OnStopRequest when restoring from session history.
+    nsLoadFlags loadFlags;
+    DebugOnly<nsresult> rv = mChannel->GetLoadFlags(&loadFlags);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "GetLoadFlags() failed!");
+
+    if (loadFlags & nsIRequest::LOAD_BACKGROUND) {
+      ModifyLoadFlags(loadFlags & ~nsIRequest::LOAD_BACKGROUND);
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult
+ChannelMediaResource::OnChannelRedirect(nsIChannel* aOld, nsIChannel* aNew,
+                                        uint32_t aFlags)
+{
+  mChannel = aNew;
+  mSuspendAgent.NotifyChannelOpened(mChannel);
+  return SetupChannelHeaders();
+}
+
+struct CopySegmentClosure {
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  ChannelMediaResource*  mResource;
+};
+
+nsresult
+ChannelMediaResource::CopySegmentToCache(nsIInputStream *aInStream,
+                                         void *aClosure,
+                                         const char *aFromSegment,
+                                         uint32_t aToOffset,
+                                         uint32_t aCount,
+                                         uint32_t *aWriteCount)
+{
+  CopySegmentClosure* closure = static_cast<CopySegmentClosure*>(aClosure);
+
+  closure->mResource->mCallback->NotifyDataArrived();
+
+  // Keep track of where we're up to.
+  RESOURCE_LOG("%p [ChannelMediaResource]: CopySegmentToCache at mOffset [%lld] add "
+               "[%d] bytes for decoder[%p]",
+               closure->mResource, closure->mResource->mOffset, aCount,
+               closure->mResource->mCallback.get());
+  closure->mResource->mOffset += aCount;
+
+  closure->mResource->mCacheStream.NotifyDataReceived(aCount, aFromSegment,
+                                                      closure->mPrincipal);
+  *aWriteCount = aCount;
+  return NS_OK;
+}
+
+nsresult
+ChannelMediaResource::OnDataAvailable(nsIRequest* aRequest,
+                                      nsIInputStream* aStream,
+                                      uint32_t aCount)
+{
+  NS_ASSERTION(mChannel.get() == aRequest, "Wrong channel!");
+
+  {
+    MutexAutoLock lock(mLock);
+    mChannelStatistics->AddBytes(aCount);
+  }
+
+  CopySegmentClosure closure;
+  nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
+  if (secMan && mChannel) {
+    secMan->GetChannelResultPrincipal(mChannel, getter_AddRefs(closure.mPrincipal));
+  }
+  closure.mResource = this;
+
+  uint32_t count = aCount;
+  while (count > 0) {
+    uint32_t read;
+    nsresult rv = aStream->ReadSegments(CopySegmentToCache, &closure, count,
+                                        &read);
+    if (NS_FAILED(rv))
+      return rv;
+    NS_ASSERTION(read > 0, "Read 0 bytes while data was available?");
+    count -= read;
+  }
+
+  return NS_OK;
+}
+
+nsresult ChannelMediaResource::Open(nsIStreamListener **aStreamListener)
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  if (!mChannelStatistics) {
+    mChannelStatistics = new MediaChannelStatistics();
+  }
+
+  nsresult rv = mCacheStream.Init();
+  if (NS_FAILED(rv))
+    return rv;
+  NS_ASSERTION(mOffset == 0, "Who set mOffset already?");
+
+  if (!mChannel) {
+    // When we're a clone, the decoder might ask us to Open even though
+    // we haven't established an mChannel (because we might not need one)
+    NS_ASSERTION(!aStreamListener,
+                 "Should have already been given a channel if we're to return a stream listener");
+    return NS_OK;
+  }
+
+  return OpenChannel(aStreamListener);
+}
+
+nsresult ChannelMediaResource::OpenChannel(nsIStreamListener** aStreamListener)
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+  NS_ENSURE_TRUE(mChannel, NS_ERROR_NULL_POINTER);
+  NS_ASSERTION(!mListener, "Listener should have been removed by now");
+
+  if (aStreamListener) {
+    *aStreamListener = nullptr;
+  }
+
+  // Set the content length, if it's available as an HTTP header.
+  // This ensures that MediaResource wrapping objects for platform libraries
+  // that expect to know the length of a resource can get it before
+  // OnStartRequest() fires.
+  nsCOMPtr<nsIHttpChannel> hc = do_QueryInterface(mChannel);
+  if (hc) {
+    int64_t cl = -1;
+    if (NS_SUCCEEDED(hc->GetContentLength(&cl)) && cl != -1) {
+      mCacheStream.NotifyDataLength(cl);
+    }
+  }
+
+  mListener = new Listener(this);
+  if (aStreamListener) {
+    *aStreamListener = mListener;
+    NS_ADDREF(*aStreamListener);
+  } else {
+    nsresult rv = mChannel->SetNotificationCallbacks(mListener.get());
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = SetupChannelHeaders();
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = mChannel->AsyncOpen2(mListener);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Tell the media element that we are fetching data from a channel.
+    MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+    NS_ENSURE_TRUE(owner, NS_ERROR_FAILURE);
+    dom::HTMLMediaElement* element = owner->GetMediaElement();
+    element->DownloadResumed(true);
+  }
+
+  return NS_OK;
+}
+
+nsresult ChannelMediaResource::SetupChannelHeaders()
+{
+  // Always use a byte range request even if we're reading from the start
+  // of the resource.
+  // This enables us to detect if the stream supports byte range
+  // requests, and therefore seeking, early.
+  nsCOMPtr<nsIHttpChannel> hc = do_QueryInterface(mChannel);
+  if (hc) {
+    // Use |mOffset| if seeking in a complete file download.
+    nsAutoCString rangeString("bytes=");
+    rangeString.AppendInt(mOffset);
+    rangeString.Append('-');
+    nsresult rv = hc->SetRequestHeader(NS_LITERAL_CSTRING("Range"), rangeString, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Send Accept header for video and audio types only (Bug 489071)
+    NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+    MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+    NS_ENSURE_TRUE(owner, NS_ERROR_FAILURE);
+    dom::HTMLMediaElement* element = owner->GetMediaElement();
+    NS_ENSURE_TRUE(element, NS_ERROR_FAILURE);
+    element->SetRequestHeaders(hc);
+  } else {
+    NS_ASSERTION(mOffset == 0, "Don't know how to seek on this channel type");
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+nsresult ChannelMediaResource::Close()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  mCacheStream.Close();
+  CloseChannel();
+  return NS_OK;
+}
+
+already_AddRefed<nsIPrincipal> ChannelMediaResource::GetCurrentPrincipal()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  nsCOMPtr<nsIPrincipal> principal = mCacheStream.GetCurrentPrincipal();
+  return principal.forget();
+}
+
+bool ChannelMediaResource::CanClone()
+{
+  return mCacheStream.IsAvailableForSharing();
+}
+
+already_AddRefed<MediaResource> ChannelMediaResource::CloneData(MediaResourceCallback* aCallback)
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+  NS_ASSERTION(mCacheStream.IsAvailableForSharing(), "Stream can't be cloned");
+
+  RefPtr<ChannelMediaResource> resource =
+    new ChannelMediaResource(aCallback,
+                             nullptr,
+                             mURI,
+                             GetContentType());
+  if (resource) {
+    // Initially the clone is treated as suspended by the cache, because
+    // we don't have a channel. If the cache needs to read data from the clone
+    // it will call CacheClientResume (or CacheClientSeek with aResume true)
+    // which will recreate the channel. This way, if all of the media data
+    // is already in the cache we don't create an unnecessary HTTP channel
+    // and perform a useless HTTP transaction.
+    resource->mSuspendAgent.Suspend();
+    resource->mCacheStream.InitAsClone(&mCacheStream);
+    resource->mChannelStatistics = new MediaChannelStatistics(mChannelStatistics);
+    resource->mChannelStatistics->Stop();
+  }
+  return resource.forget();
+}
+
+void ChannelMediaResource::CloseChannel()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  {
+    MutexAutoLock lock(mLock);
+    mChannelStatistics->Stop();
+  }
+
+  if (mListener) {
+    mListener->Revoke();
+    mListener = nullptr;
+  }
+
+  if (mChannel) {
+    mSuspendAgent.NotifyChannelClosing();
+    // The status we use here won't be passed to the decoder, since
+    // we've already revoked the listener. It can however be passed
+    // to nsDocumentViewer::LoadComplete if our channel is the one
+    // that kicked off creation of a video document. We don't want that
+    // document load to think there was an error.
+    // NS_ERROR_PARSED_DATA_CACHED is the best thing we have for that
+    // at the moment.
+    mChannel->Cancel(NS_ERROR_PARSED_DATA_CACHED);
+    mChannel = nullptr;
+  }
+}
+
+nsresult ChannelMediaResource::ReadFromCache(char* aBuffer,
+                                             int64_t aOffset,
+                                             uint32_t aCount)
+{
+  return mCacheStream.ReadFromCache(aBuffer, aOffset, aCount);
+}
+
+nsresult ChannelMediaResource::ReadAt(int64_t aOffset,
+                                      char* aBuffer,
+                                      uint32_t aCount,
+                                      uint32_t* aBytes)
+{
+  NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
+
+  nsresult rv = mCacheStream.ReadAt(aOffset, aBuffer, aCount, aBytes);
+  if (NS_SUCCEEDED(rv)) {
+    DispatchBytesConsumed(*aBytes, aOffset);
+  }
+  return rv;
+}
+
+already_AddRefed<MediaByteBuffer>
+ChannelMediaResource::MediaReadAt(int64_t aOffset, uint32_t aCount)
+{
+  NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
+
+  RefPtr<MediaByteBuffer> bytes = new MediaByteBuffer();
+  bool ok = bytes->SetLength(aCount, fallible);
+  NS_ENSURE_TRUE(ok, nullptr);
+  char* curr = reinterpret_cast<char*>(bytes->Elements());
+  const char* start = curr;
+  while (aCount > 0) {
+    uint32_t bytesRead;
+    nsresult rv = mCacheStream.ReadAt(aOffset, curr, aCount, &bytesRead);
+    NS_ENSURE_SUCCESS(rv, nullptr);
+    if (!bytesRead) {
+      break;
+    }
+    aOffset += bytesRead;
+    aCount -= bytesRead;
+    curr += bytesRead;
+  }
+  bytes->SetLength(curr - start);
+  return bytes.forget();
+}
+
+int64_t ChannelMediaResource::Tell()
+{
+  return mCacheStream.Tell();
+}
+
+nsresult ChannelMediaResource::GetCachedRanges(MediaByteRangeSet& aRanges)
+{
+  return mCacheStream.GetCachedRanges(aRanges);
+}
+
+void ChannelMediaResource::Suspend(bool aCloseImmediately)
+{
+  NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+
+  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+  if (!owner) {
+    // Shutting down; do nothing.
+    return;
+  }
+  dom::HTMLMediaElement* element = owner->GetMediaElement();
+  if (!element) {
+    // Shutting down; do nothing.
+    return;
+  }
+
+  if (mChannel && aCloseImmediately && mCacheStream.IsTransportSeekable()) {
+    // Kill off our channel right now, but don't tell anyone about it.
+    mIgnoreClose = true;
+    CloseChannel();
+    element->DownloadSuspended();
+  }
+
+  if (mSuspendAgent.Suspend()) {
+    if (mChannel) {
+      {
+        MutexAutoLock lock(mLock);
+        mChannelStatistics->Stop();
+      }
+      element->DownloadSuspended();
+    }
+  }
+}
+
+void ChannelMediaResource::Resume()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+
+  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+  if (!owner) {
+    // Shutting down; do nothing.
+    return;
+  }
+  dom::HTMLMediaElement* element = owner->GetMediaElement();
+  if (!element) {
+    // Shutting down; do nothing.
+    return;
+  }
+
+  if (mSuspendAgent.Resume()) {
+    if (mChannel) {
+      // Just wake up our existing channel
+      {
+        MutexAutoLock lock(mLock);
+        mChannelStatistics->Start();
+      }
+      // if an error occurs after Resume, assume it's because the server
+      // timed out the connection and we should reopen it.
+      mReopenOnError = true;
+      element->DownloadResumed();
+    } else {
+      int64_t totalLength = mCacheStream.GetLength();
+      // If mOffset is at the end of the stream, then we shouldn't try to
+      // seek to it. The seek will fail and be wasted anyway. We can leave
+      // the channel dead; if the media cache wants to read some other data
+      // in the future, it will call CacheClientSeek itself which will reopen the
+      // channel.
+      if (totalLength < 0 || mOffset < totalLength) {
+        // There is (or may be) data to read at mOffset, so start reading it.
+        // Need to recreate the channel.
+        CacheClientSeek(mOffset, false);
+        element->DownloadResumed();
+      } else {
+        // The channel remains dead. Do not notify DownloadResumed() which
+        // will leave the media element in NETWORK_LOADING state.
+      }
+    }
+  }
+}
+
+nsresult
+ChannelMediaResource::RecreateChannel()
+{
+  nsLoadFlags loadFlags =
+    nsICachingChannel::LOAD_BYPASS_LOCAL_CACHE_IF_BUSY |
+    nsIChannel::LOAD_CLASSIFY_URI |
+    (mLoadInBackground ? nsIRequest::LOAD_BACKGROUND : 0);
+
+  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+  if (!owner) {
+    // The decoder is being shut down, so don't bother opening a new channel
+    return NS_OK;
+  }
+  dom::HTMLMediaElement* element = owner->GetMediaElement();
+  if (!element) {
+    // The decoder is being shut down, so don't bother opening a new channel
+    return NS_OK;
+  }
+  nsCOMPtr<nsILoadGroup> loadGroup = element->GetDocumentLoadGroup();
+  NS_ENSURE_TRUE(loadGroup, NS_ERROR_NULL_POINTER);
+
+  nsSecurityFlags securityFlags = element->ShouldCheckAllowOrigin()
+                                  ? nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS
+                                  : nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS;
+
+  MOZ_ASSERT(element->IsAnyOfHTMLElements(nsGkAtoms::audio, nsGkAtoms::video));
+  nsContentPolicyType contentPolicyType = element->IsHTMLElement(nsGkAtoms::audio) ?
+    nsIContentPolicy::TYPE_INTERNAL_AUDIO : nsIContentPolicy::TYPE_INTERNAL_VIDEO;
+
+  nsresult rv = NS_NewChannel(getter_AddRefs(mChannel),
+                              mURI,
+                              element,
+                              securityFlags,
+                              contentPolicyType,
+                              loadGroup,
+                              nullptr,  // aCallbacks
+                              loadFlags);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // We have cached the Content-Type, which should not change. Give a hint to
+  // the channel to avoid a sniffing failure, which would be expected because we
+  // are probably seeking in the middle of the bitstream, and sniffing relies
+  // on the presence of a magic number at the beginning of the stream.
+  NS_ASSERTION(!GetContentType().IsEmpty(),
+      "When recreating a channel, we should know the Content-Type.");
+  mChannel->SetContentType(GetContentType());
+  mSuspendAgent.NotifyChannelOpened(mChannel);
+
+  // Tell the cache to reset the download status when the channel is reopened.
+  mCacheStream.NotifyChannelRecreated();
+
+  return rv;
+}
+
+void
+ChannelMediaResource::DoNotifyDataReceived()
+{
+  mDataReceivedEvent.Revoke();
+  mCallback->NotifyBytesDownloaded();
+}
+
+void
+ChannelMediaResource::CacheClientNotifyDataReceived()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+  // NOTE: this can be called with the media cache lock held, so don't
+  // block or do anything which might try to acquire a lock!
+
+  if (mDataReceivedEvent.IsPending())
+    return;
+
+  mDataReceivedEvent =
+    NewNonOwningRunnableMethod(this, &ChannelMediaResource::DoNotifyDataReceived);
+  NS_DispatchToMainThread(mDataReceivedEvent.get());
+}
+
+void
+ChannelMediaResource::CacheClientNotifyDataEnded(nsresult aStatus)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  mCallback->NotifyDataEnded(aStatus);
+}
+
+void
+ChannelMediaResource::CacheClientNotifyPrincipalChanged()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+
+  mCallback->NotifyPrincipalChanged();
+}
+
+void
+ChannelMediaResource::CacheClientNotifySuspendedStatusChanged()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+  mCallback->NotifySuspendedStatusChanged();
+}
+
+nsresult
+ChannelMediaResource::CacheClientSeek(int64_t aOffset, bool aResume)
+{
+  NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+
+  CMLOG("CacheClientSeek requested for aOffset [%lld] for decoder [%p]",
+        aOffset, mCallback.get());
+
+  CloseChannel();
+
+  mOffset = aOffset;
+
+  // Don't report close of the channel because the channel is not closed for
+  // download ended, but for internal changes in the read position.
+  mIgnoreClose = true;
+
+  if (aResume) {
+    mSuspendAgent.Resume();
+  }
+
+  // Don't create a new channel if we are still suspended. The channel will
+  // be recreated when we are resumed.
+  if (mSuspendAgent.IsSuspended()) {
+    return NS_OK;
+  }
+
+  nsresult rv = RecreateChannel();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return OpenChannel(nullptr);
+}
+
+void
+ChannelMediaResource::FlushCache()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
+
+  // Ensure that data in the cache's partial block is written to disk.
+  mCacheStream.FlushPartialBlock();
+}
+
+void
+ChannelMediaResource::NotifyLastByteRange()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
+
+  // Tell media cache that the last data has been downloaded.
+  // Note: subsequent seeks will require re-opening the channel etc.
+  mCacheStream.NotifyDataEnded(NS_OK);
+
+}
+
+nsresult
+ChannelMediaResource::CacheClientSuspend()
+{
+  Suspend(false);
+  return NS_OK;
+}
+
+nsresult
+ChannelMediaResource::CacheClientResume()
+{
+  Resume();
+  return NS_OK;
+}
+
+int64_t
+ChannelMediaResource::GetNextCachedData(int64_t aOffset)
+{
+  return mCacheStream.GetNextCachedData(aOffset);
+}
+
+int64_t
+ChannelMediaResource::GetCachedDataEnd(int64_t aOffset)
+{
+  return mCacheStream.GetCachedDataEnd(aOffset);
+}
+
+bool
+ChannelMediaResource::IsDataCachedToEndOfResource(int64_t aOffset)
+{
+  return mCacheStream.IsDataCachedToEndOfStream(aOffset);
+}
+
+void
+ChannelMediaResource::EnsureCacheUpToDate()
+{
+  mCacheStream.EnsureCacheUpdate();
+}
+
+bool
+ChannelMediaResource::IsSuspendedByCache()
+{
+  return mCacheStream.AreAllStreamsForResourceSuspended();
+}
+
+bool
+ChannelMediaResource::IsSuspended()
+{
+  return mSuspendAgent.IsSuspended();
+}
+
+void
+ChannelMediaResource::SetReadMode(MediaCacheStream::ReadMode aMode)
+{
+  mCacheStream.SetReadMode(aMode);
+}
+
+void
+ChannelMediaResource::SetPlaybackRate(uint32_t aBytesPerSecond)
+{
+  mCacheStream.SetPlaybackRate(aBytesPerSecond);
+}
+
+void
+ChannelMediaResource::Pin()
+{
+  mCacheStream.Pin();
+}
+
+void
+ChannelMediaResource::Unpin()
+{
+  mCacheStream.Unpin();
+}
+
+double
+ChannelMediaResource::GetDownloadRate(bool* aIsReliable)
+{
+  MutexAutoLock lock(mLock);
+  return mChannelStatistics->GetRate(aIsReliable);
+}
+
+int64_t
+ChannelMediaResource::GetLength()
+{
+  return mCacheStream.GetLength();
+}
+
+// ChannelSuspendAgent
+
+bool
+ChannelSuspendAgent::Suspend()
+{
+  SuspendInternal();
+  return (++mSuspendCount == 1);
+}
+
+void
+ChannelSuspendAgent::SuspendInternal()
+{
+  if (mChannel) {
+    bool isPending = false;
+    nsresult rv = mChannel->IsPending(&isPending);
+    if (NS_SUCCEEDED(rv) && isPending && !mIsChannelSuspended) {
+      mChannel->Suspend();
+      mIsChannelSuspended = true;
+    }
+  }
+}
+
+bool
+ChannelSuspendAgent::Resume()
+{
+  MOZ_ASSERT(IsSuspended(), "Resume without suspend!");
+  --mSuspendCount;
+
+  if (mSuspendCount == 0) {
+    if (mChannel && mIsChannelSuspended) {
+      mChannel->Resume();
+      mIsChannelSuspended = false;
+    }
+    return true;
+  }
+  return false;
+}
+
+void
+ChannelSuspendAgent::UpdateSuspendedStatusIfNeeded()
+{
+  if (!mIsChannelSuspended && IsSuspended()) {
+    SuspendInternal();
+  }
+}
+
+void
+ChannelSuspendAgent::NotifyChannelOpened(nsIChannel* aChannel)
+{
+  MOZ_ASSERT(aChannel);
+  mChannel = aChannel;
+}
+
+void
+ChannelSuspendAgent::NotifyChannelClosing()
+{
+  MOZ_ASSERT(mChannel);
+  // Before close the channel, it need to be resumed to make sure its internal
+  // state is correct. Besides, We need to suspend the channel after recreating.
+  if (mIsChannelSuspended) {
+    mChannel->Resume();
+    mIsChannelSuspended = false;
+  }
+  mChannel = nullptr;
+}
+
+bool
+ChannelSuspendAgent::IsSuspended()
+{
+  return (mSuspendCount > 0);
+}
+
+// FileMediaResource
+
+class FileMediaResource : public BaseMediaResource
+{
+public:
+  FileMediaResource(MediaResourceCallback* aCallback,
+                    nsIChannel* aChannel,
+                    nsIURI* aURI,
+                    const nsACString& aContentType) :
+    BaseMediaResource(aCallback, aChannel, aURI, aContentType),
+    mSize(-1),
+    mLock("FileMediaResource.mLock"),
+    mSizeInitialized(false)
+  {
+  }
+  ~FileMediaResource()
+  {
+  }
+
+  // Main thread
+  nsresult Open(nsIStreamListener** aStreamListener) override;
+  nsresult Close() override;
+  void     Suspend(bool aCloseImmediately) override {}
+  void     Resume() override {}
+  already_AddRefed<nsIPrincipal> GetCurrentPrincipal() override;
+  bool     CanClone() override;
+  already_AddRefed<MediaResource> CloneData(MediaResourceCallback* aCallback) override;
+  nsresult ReadFromCache(char* aBuffer, int64_t aOffset, uint32_t aCount) override;
+
+  // These methods are called off the main thread.
+
+  // Other thread
+  void     SetReadMode(MediaCacheStream::ReadMode aMode) override {}
+  void     SetPlaybackRate(uint32_t aBytesPerSecond) override {}
+  nsresult ReadAt(int64_t aOffset, char* aBuffer,
+                  uint32_t aCount, uint32_t* aBytes) override;
+  already_AddRefed<MediaByteBuffer> MediaReadAt(int64_t aOffset, uint32_t aCount) override;
+  int64_t  Tell() override;
+
+  // Any thread
+  void    Pin() override {}
+  void    Unpin() override {}
+  double  GetDownloadRate(bool* aIsReliable) override
+  {
+    // The data's all already here
+    *aIsReliable = true;
+    return 100*1024*1024; // arbitray, use 100MB/s
+  }
+  int64_t GetLength() override {
+    MutexAutoLock lock(mLock);
+
+    EnsureSizeInitialized();
+    return mSizeInitialized ? mSize : 0;
+  }
+  int64_t GetNextCachedData(int64_t aOffset) override
+  {
+    MutexAutoLock lock(mLock);
+
+    EnsureSizeInitialized();
+    return (aOffset < mSize) ? aOffset : -1;
+  }
+  int64_t GetCachedDataEnd(int64_t aOffset) override {
+    MutexAutoLock lock(mLock);
+
+    EnsureSizeInitialized();
+    return std::max(aOffset, mSize);
+  }
+  bool    IsDataCachedToEndOfResource(int64_t aOffset) override { return true; }
+  bool    IsSuspendedByCache() override { return true; }
+  bool    IsSuspended() override { return true; }
+  bool    IsTransportSeekable() override { return true; }
+
+  nsresult GetCachedRanges(MediaByteRangeSet& aRanges) override;
+
+  size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override
+  {
+    // Might be useful to track in the future:
+    // - mInput
+    return BaseMediaResource::SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override
+  {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+protected:
+  // These Unsafe variants of Read and Seek perform their operations
+  // without acquiring mLock. The caller must obtain the lock before
+  // calling. The implmentation of Read, Seek and ReadAt obtains the
+  // lock before calling these Unsafe variants to read or seek.
+  nsresult UnsafeRead(char* aBuffer, uint32_t aCount, uint32_t* aBytes);
+  nsresult UnsafeSeek(int32_t aWhence, int64_t aOffset);
+private:
+  // Ensures mSize is initialized, if it can be.
+  // mLock must be held when this is called, and mInput must be non-null.
+  void EnsureSizeInitialized();
+  already_AddRefed<MediaByteBuffer> UnsafeMediaReadAt(
+                        int64_t aOffset, uint32_t aCount);
+
+  // The file size, or -1 if not known. Immutable after Open().
+  // Can be used from any thread.
+  int64_t mSize;
+
+  // This lock handles synchronisation between calls to Close() and
+  // the Read, Seek, etc calls. Close must not be called while a
+  // Read or Seek is in progress since it resets various internal
+  // values to null.
+  // This lock protects mSeekable, mInput, mSize, and mSizeInitialized.
+  Mutex mLock;
+
+  // Seekable stream interface to file. This can be used from any
+  // thread.
+  nsCOMPtr<nsISeekableStream> mSeekable;
+
+  // Input stream for the media data. This can be used from any
+  // thread.
+  nsCOMPtr<nsIInputStream>  mInput;
+
+  // Whether we've attempted to initialize mSize. Note that mSize can be -1
+  // when mSizeInitialized is true if we tried and failed to get the size
+  // of the file.
+  bool mSizeInitialized;
+};
+
+void FileMediaResource::EnsureSizeInitialized()
+{
+  mLock.AssertCurrentThreadOwns();
+  NS_ASSERTION(mInput, "Must have file input stream");
+  if (mSizeInitialized) {
+    return;
+  }
+  mSizeInitialized = true;
+  // Get the file size and inform the decoder.
+  uint64_t size;
+  nsresult res = mInput->Available(&size);
+  if (NS_SUCCEEDED(res) && size <= INT64_MAX) {
+    mSize = (int64_t)size;
+    mCallback->NotifyDataEnded(NS_OK);
+  }
+}
+
+nsresult FileMediaResource::GetCachedRanges(MediaByteRangeSet& aRanges)
+{
+  MutexAutoLock lock(mLock);
+
+  EnsureSizeInitialized();
+  if (mSize == -1) {
+    return NS_ERROR_FAILURE;
+  }
+  aRanges += MediaByteRange(0, mSize);
+  return NS_OK;
+}
+
+nsresult FileMediaResource::Open(nsIStreamListener** aStreamListener)
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  if (aStreamListener) {
+    *aStreamListener = nullptr;
+  }
+
+  nsresult rv = NS_OK;
+  if (aStreamListener) {
+    // The channel is already open. We need a synchronous stream that
+    // implements nsISeekableStream, so we have to find the underlying
+    // file and reopen it
+    nsCOMPtr<nsIFileChannel> fc(do_QueryInterface(mChannel));
+    if (fc) {
+      nsCOMPtr<nsIFile> file;
+      rv = fc->GetFile(getter_AddRefs(file));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = NS_NewLocalFileInputStream(
+        getter_AddRefs(mInput), file, -1, -1, nsIFileInputStream::SHARE_DELETE);
+    } else if (IsBlobURI(mURI)) {
+      rv = NS_GetStreamForBlobURI(mURI, getter_AddRefs(mInput));
+    }
+  } else {
+    rv = mChannel->Open2(getter_AddRefs(mInput));
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mSeekable = do_QueryInterface(mInput);
+  if (!mSeekable) {
+    // XXX The file may just be a .url or similar
+    // shortcut that points to a Web site. We need to fix this by
+    // doing an async open and waiting until we locate the real resource,
+    // then using that (if it's still a file!).
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+nsresult FileMediaResource::Close()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  // Since mChennel is only accessed by main thread, there is no necessary to
+  // take the lock.
+  if (mChannel) {
+    mChannel->Cancel(NS_ERROR_PARSED_DATA_CACHED);
+    mChannel = nullptr;
+  }
+
+  return NS_OK;
+}
+
+already_AddRefed<nsIPrincipal> FileMediaResource::GetCurrentPrincipal()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  nsCOMPtr<nsIPrincipal> principal;
+  nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
+  if (!secMan || !mChannel)
+    return nullptr;
+  secMan->GetChannelResultPrincipal(mChannel, getter_AddRefs(principal));
+  return principal.forget();
+}
+
+bool FileMediaResource::CanClone()
+{
+  return true;
+}
+
+already_AddRefed<MediaResource> FileMediaResource::CloneData(MediaResourceCallback* aCallback)
+{
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+  if (!owner) {
+    // The decoder is being shut down, so we can't clone
+    return nullptr;
+  }
+  dom::HTMLMediaElement* element = owner->GetMediaElement();
+  if (!element) {
+    // The decoder is being shut down, so we can't clone
+    return nullptr;
+  }
+  nsCOMPtr<nsILoadGroup> loadGroup = element->GetDocumentLoadGroup();
+  NS_ENSURE_TRUE(loadGroup, nullptr);
+
+  MOZ_ASSERT(element->IsAnyOfHTMLElements(nsGkAtoms::audio, nsGkAtoms::video));
+  nsContentPolicyType contentPolicyType = element->IsHTMLElement(nsGkAtoms::audio) ?
+    nsIContentPolicy::TYPE_INTERNAL_AUDIO : nsIContentPolicy::TYPE_INTERNAL_VIDEO;
+
+  nsLoadFlags loadFlags = nsIRequest::LOAD_NORMAL | nsIChannel::LOAD_CLASSIFY_URI;
+
+  nsCOMPtr<nsIChannel> channel;
+  nsresult rv =
+    NS_NewChannel(getter_AddRefs(channel),
+                  mURI,
+                  element,
+                  nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS,
+                  contentPolicyType,
+                  loadGroup,
+                  nullptr,  // aCallbacks
+                  loadFlags);
+
+  if (NS_FAILED(rv))
+    return nullptr;
+
+  RefPtr<MediaResource> resource(new FileMediaResource(aCallback, channel, mURI, GetContentType()));
+  return resource.forget();
+}
+
+nsresult FileMediaResource::ReadFromCache(char* aBuffer, int64_t aOffset, uint32_t aCount)
+{
+  MutexAutoLock lock(mLock);
+
+  EnsureSizeInitialized();
+  if (!aCount) {
+    return NS_OK;
+  }
+  int64_t offset = 0;
+  nsresult res = mSeekable->Tell(&offset);
+  NS_ENSURE_SUCCESS(res,res);
+  res = mSeekable->Seek(nsISeekableStream::NS_SEEK_SET, aOffset);
+  NS_ENSURE_SUCCESS(res,res);
+  uint32_t bytesRead = 0;
+  do {
+    uint32_t x = 0;
+    uint32_t bytesToRead = aCount - bytesRead;
+    res = mInput->Read(aBuffer, bytesToRead, &x);
+    bytesRead += x;
+    if (!x) {
+      res = NS_ERROR_FAILURE;
+    }
+  } while (bytesRead != aCount && res == NS_OK);
+
+  // Reset read head to original position so we don't disturb any other
+  // reading thread.
+  nsresult seekres = mSeekable->Seek(nsISeekableStream::NS_SEEK_SET, offset);
+
+  // If a read failed in the loop above, we want to return its failure code.
+  NS_ENSURE_SUCCESS(res,res);
+
+  // Else we succeed if the reset-seek succeeds.
+  return seekres;
+}
+
+nsresult FileMediaResource::UnsafeRead(char* aBuffer, uint32_t aCount, uint32_t* aBytes)
+{
+  EnsureSizeInitialized();
+  return mInput->Read(aBuffer, aCount, aBytes);
+}
+
+nsresult FileMediaResource::ReadAt(int64_t aOffset, char* aBuffer,
+                                   uint32_t aCount, uint32_t* aBytes)
+{
+  NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
+
+  nsresult rv;
+  {
+    MutexAutoLock lock(mLock);
+    rv = UnsafeSeek(nsISeekableStream::NS_SEEK_SET, aOffset);
+    if (NS_FAILED(rv)) return rv;
+    rv = UnsafeRead(aBuffer, aCount, aBytes);
+  }
+  if (NS_SUCCEEDED(rv)) {
+    DispatchBytesConsumed(*aBytes, aOffset);
+  }
+  return rv;
+}
+
+already_AddRefed<MediaByteBuffer>
+FileMediaResource::MediaReadAt(int64_t aOffset, uint32_t aCount)
+{
+  NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
+
+  MutexAutoLock lock(mLock);
+  return UnsafeMediaReadAt(aOffset, aCount);
+}
+
+already_AddRefed<MediaByteBuffer>
+FileMediaResource::UnsafeMediaReadAt(int64_t aOffset, uint32_t aCount)
+{
+  RefPtr<MediaByteBuffer> bytes = new MediaByteBuffer();
+  bool ok = bytes->SetLength(aCount, fallible);
+  NS_ENSURE_TRUE(ok, nullptr);
+  nsresult rv = UnsafeSeek(nsISeekableStream::NS_SEEK_SET, aOffset);
+  NS_ENSURE_SUCCESS(rv, nullptr);
+  char* curr = reinterpret_cast<char*>(bytes->Elements());
+  const char* start = curr;
+  while (aCount > 0) {
+    uint32_t bytesRead;
+    rv = UnsafeRead(curr, aCount, &bytesRead);
+    NS_ENSURE_SUCCESS(rv, nullptr);
+    if (!bytesRead) {
+      break;
+    }
+    aCount -= bytesRead;
+    curr += bytesRead;
+  }
+  bytes->SetLength(curr - start);
+  return bytes.forget();
+}
+
+nsresult FileMediaResource::UnsafeSeek(int32_t aWhence, int64_t aOffset)
+{
+  NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
+
+  if (!mSeekable)
+    return NS_ERROR_FAILURE;
+  EnsureSizeInitialized();
+  return mSeekable->Seek(aWhence, aOffset);
+}
+
+int64_t FileMediaResource::Tell()
+{
+  MutexAutoLock lock(mLock);
+  EnsureSizeInitialized();
+
+  int64_t offset = 0;
+  // Return mSize as offset (end of stream) in case of error
+  if (!mSeekable || NS_FAILED(mSeekable->Tell(&offset)))
+    return mSize;
+  return offset;
+}
+
+already_AddRefed<MediaResource>
+MediaResource::Create(MediaResourceCallback* aCallback, nsIChannel* aChannel)
+{
+  NS_ASSERTION(NS_IsMainThread(),
+               "MediaResource::Open called on non-main thread");
+
+  // If the channel was redirected, we want the post-redirect URI;
+  // but if the URI scheme was expanded, say from chrome: to jar:file:,
+  // we want the original URI.
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  nsAutoCString contentType;
+  aChannel->GetContentType(contentType);
+
+  nsCOMPtr<nsIFileChannel> fc = do_QueryInterface(aChannel);
+  RefPtr<MediaResource> resource;
+  if (fc || IsBlobURI(uri)) {
+    resource = new FileMediaResource(aCallback, aChannel, uri, contentType);
+  } else {
+    resource = new ChannelMediaResource(aCallback, aChannel, uri, contentType);
+  }
+  return resource.forget();
+}
+
+void BaseMediaResource::SetLoadInBackground(bool aLoadInBackground) {
+  if (aLoadInBackground == mLoadInBackground) {
+    return;
+  }
+  mLoadInBackground = aLoadInBackground;
+  if (!mChannel) {
+    // No channel, resource is probably already loaded.
+    return;
+  }
+
+  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+  if (!owner) {
+    NS_WARNING("Null owner in MediaResource::SetLoadInBackground()");
+    return;
+  }
+  dom::HTMLMediaElement* element = owner->GetMediaElement();
+  if (!element) {
+    NS_WARNING("Null element in MediaResource::SetLoadInBackground()");
+    return;
+  }
+
+  bool isPending = false;
+  if (NS_SUCCEEDED(mChannel->IsPending(&isPending)) &&
+      isPending) {
+    nsLoadFlags loadFlags;
+    DebugOnly<nsresult> rv = mChannel->GetLoadFlags(&loadFlags);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "GetLoadFlags() failed!");
+
+    if (aLoadInBackground) {
+      loadFlags |= nsIRequest::LOAD_BACKGROUND;
+    } else {
+      loadFlags &= ~nsIRequest::LOAD_BACKGROUND;
+    }
+    ModifyLoadFlags(loadFlags);
+  }
+}
+
+void BaseMediaResource::ModifyLoadFlags(nsLoadFlags aFlags)
+{
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  nsresult rv = mChannel->GetLoadGroup(getter_AddRefs(loadGroup));
+  MOZ_ASSERT(NS_SUCCEEDED(rv), "GetLoadGroup() failed!");
+
+  nsresult status;
+  mChannel->GetStatus(&status);
+
+  bool inLoadGroup = false;
+  if (loadGroup) {
+    rv = loadGroup->RemoveRequest(mChannel, nullptr, status);
+    if (NS_SUCCEEDED(rv)) {
+      inLoadGroup = true;
+    }
+  }
+
+  rv = mChannel->SetLoadFlags(aFlags);
+  MOZ_ASSERT(NS_SUCCEEDED(rv), "SetLoadFlags() failed!");
+
+  if (inLoadGroup) {
+    rv = loadGroup->AddRequest(mChannel, nullptr);
+    MOZ_ASSERT(NS_SUCCEEDED(rv), "AddRequest() failed!");
+  }
+}
+
+void BaseMediaResource::DispatchBytesConsumed(int64_t aNumBytes, int64_t aOffset)
+{
+  if (aNumBytes <= 0) {
+    return;
+  }
+  mCallback->NotifyBytesConsumed(aNumBytes, aOffset);
+}
+
+nsresult
+MediaResourceIndex::Read(char* aBuffer, uint32_t aCount, uint32_t* aBytes)
+{
+  NS_ASSERTION(!NS_IsMainThread(), "Don't call on main thread");
+
+  // We purposefuly don't check that we may attempt to read past
+  // mResource->GetLength() as the resource's length may change over time.
+
+  nsresult rv = ReadAt(mOffset, aBuffer, aCount, aBytes);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  mOffset += *aBytes;
+  return NS_OK;
+}
+
+nsresult
+MediaResourceIndex::ReadAt(int64_t aOffset, char* aBuffer,
+                           uint32_t aCount, uint32_t* aBytes) const
+{
+  *aBytes = 0;
+  while (aCount > 0) {
+    uint32_t bytesRead = 0;
+    nsresult rv = mResource->ReadAt(aOffset, aBuffer, aCount, &bytesRead);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!bytesRead) {
+      break;
+    }
+    *aBytes += bytesRead;
+    aOffset += bytesRead;
+    aBuffer += bytesRead;
+    aCount -= bytesRead;
+  }
+  return NS_OK;
+}
+
+nsresult
+MediaResourceIndex::Seek(int32_t aWhence, int64_t aOffset)
+{
+  switch (aWhence) {
+    case SEEK_SET:
+      break;
+    case SEEK_CUR:
+      aOffset += mOffset;
+      break;
+    case SEEK_END:
+    {
+      int64_t length = mResource->GetLength();
+      if (length == -1 || length - aOffset < 0) {
+        return NS_ERROR_FAILURE;
+      }
+      aOffset = mResource->GetLength() - aOffset;
+    }
+      break;
+    default:
+      return NS_ERROR_FAILURE;
+  }
+
+  mOffset = aOffset;
+
+  return NS_OK;
+}
+
+} // namespace mozilla
+