Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1057 insertions, 0 deletions

diff --git a/dom/media/ChannelMediaResource.cpp b/dom/media/ChannelMediaResource.cpp
new file mode 100644
index 0000000000..aefedb37d1
--- /dev/null
+++ b/dom/media/ChannelMediaResource.cpp
@@ -0,0 +1,1057 @@
+/* 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 "ChannelMediaResource.h"
+
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/HTMLMediaElement.h"
+#include "mozilla/net/OpaqueResponseUtils.h"
+#include "nsIAsyncVerifyRedirectCallback.h"
+#include "nsICachingChannel.h"
+#include "nsIClassOfService.h"
+#include "nsIHttpChannel.h"
+#include "nsIInputStream.h"
+#include "nsIThreadRetargetableRequest.h"
+#include "nsITimedChannel.h"
+#include "nsHttp.h"
+#include "nsNetUtil.h"
+
+static const uint32_t HTTP_PARTIAL_RESPONSE_CODE = 206;
+static const uint32_t HTTP_OK_CODE = 200;
+static const uint32_t HTTP_REQUESTED_RANGE_NOT_SATISFIABLE_CODE = 416;
+
+mozilla::LazyLogModule gMediaResourceLog("MediaResource");
+// Debug logging macro with object pointer and class name.
+#define LOG(msg, ...) \
+  DDMOZ_LOG(gMediaResourceLog, mozilla::LogLevel::Debug, msg, ##__VA_ARGS__)
+
+namespace mozilla {
+
+ChannelMediaResource::ChannelMediaResource(MediaResourceCallback* aCallback,
+                                           nsIChannel* aChannel, nsIURI* aURI,
+                                           int64_t aStreamLength,
+                                           bool aIsPrivateBrowsing)
+    : BaseMediaResource(aCallback, aChannel, aURI),
+      mCacheStream(this, aIsPrivateBrowsing),
+      mSuspendAgent(mCacheStream),
+      mKnownStreamLength(aStreamLength) {}
+
+ChannelMediaResource::~ChannelMediaResource() {
+  MOZ_ASSERT(mClosed);
+  MOZ_ASSERT(!mChannel);
+  MOZ_ASSERT(!mListener);
+  if (mSharedInfo) {
+    mSharedInfo->mResources.RemoveElement(this);
+  }
+}
+
+// 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,
+                  nsIThreadRetargetableStreamListener)
+
+nsresult ChannelMediaResource::Listener::OnStartRequest(nsIRequest* aRequest) {
+  mMutex.AssertOnWritingThread();  // Writing thread is MainThread
+  if (!mResource) return NS_OK;
+  return mResource->OnStartRequest(aRequest, mOffset);
+}
+
+nsresult ChannelMediaResource::Listener::OnStopRequest(nsIRequest* aRequest,
+                                                       nsresult aStatus) {
+  mMutex.AssertOnWritingThread();
+  if (!mResource) return NS_OK;
+  return mResource->OnStopRequest(aRequest, aStatus);
+}
+
+nsresult ChannelMediaResource::Listener::OnDataAvailable(
+    nsIRequest* aRequest, nsIInputStream* aStream, uint64_t aOffset,
+    uint32_t aCount) {
+  // This might happen off the main thread.
+  RefPtr<ChannelMediaResource> res;
+  {
+    MutexSingleWriterAutoLock lock(mMutex);
+    res = mResource;
+  }
+  // Note Rekove() might happen at the same time to reset mResource. We check
+  // the load ID to determine if the data is from an old channel.
+  return res ? res->OnDataAvailable(mLoadID, aStream, aCount) : NS_OK;
+}
+
+nsresult ChannelMediaResource::Listener::AsyncOnChannelRedirect(
+    nsIChannel* aOld, nsIChannel* aNew, uint32_t aFlags,
+    nsIAsyncVerifyRedirectCallback* cb) {
+  mMutex.AssertOnWritingThread();
+
+  nsresult rv = NS_OK;
+  if (mResource) {
+    rv = mResource->OnChannelRedirect(aOld, aNew, aFlags, mOffset);
+  }
+
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  cb->OnRedirectVerifyCallback(NS_OK);
+  return NS_OK;
+}
+
+nsresult ChannelMediaResource::Listener::CheckListenerChain() { return NS_OK; }
+
+NS_IMETHODIMP
+ChannelMediaResource::Listener::OnDataFinished(nsresult) { return NS_OK; }
+
+nsresult ChannelMediaResource::Listener::GetInterface(const nsIID& aIID,
+                                                      void** aResult) {
+  return QueryInterface(aIID, aResult);
+}
+
+void ChannelMediaResource::Listener::Revoke() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MutexSingleWriterAutoLock lock(mMutex);
+  mResource = nullptr;
+}
+
+static bool IsPayloadCompressed(nsIHttpChannel* aChannel) {
+  nsAutoCString encoding;
+  Unused << aChannel->GetResponseHeader("Content-Encoding"_ns, encoding);
+  return encoding.Length() > 0;
+}
+
+nsresult ChannelMediaResource::OnStartRequest(nsIRequest* aRequest,
+                                              int64_t aRequestOffset) {
+  NS_ASSERTION(mChannel.get() == aRequest, "Wrong channel!");
+  MOZ_DIAGNOSTIC_ASSERT(!mClosed);
+
+  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+  MOZ_DIAGNOSTIC_ASSERT(owner);
+  dom::HTMLMediaElement* element = owner->GetMediaElement();
+  MOZ_DIAGNOSTIC_ASSERT(element);
+
+  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(MediaResult(status, "CORS not allowed"));
+      return NS_ERROR_DOM_BAD_URI;
+    }
+  }
+
+  nsCOMPtr<nsIHttpChannel> hc = do_QueryInterface(aRequest);
+  bool seekable = false;
+  int64_t length = -1;
+  int64_t startOffset = aRequestOffset;
+
+  if (hc) {
+    uint32_t responseStatus = 0;
+    Unused << hc->GetResponseStatus(&responseStatus);
+    bool succeeded = false;
+    Unused << 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. Note we need to pass the load ID first so the following
+        // NotifyDataEnded() can pass the ID check.
+        mCacheStream.NotifyLoadID(mLoadID);
+        mCacheStream.NotifyDataEnded(mLoadID, status);
+      } else {
+        mCallback->NotifyNetworkError(
+            MediaResult(NS_ERROR_FAILURE, "HTTP error"));
+      }
+
+      // 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;
+    Unused << hc->GetResponseHeader("Accept-Ranges"_ns, ranges);
+    bool acceptsRanges =
+        net::nsHttp::FindToken(ranges.get(), "bytes", HTTP_HEADER_VALUE_SEPS);
+
+    int64_t contentLength = -1;
+    const bool isCompressed = IsPayloadCompressed(hc);
+    if (!isCompressed) {
+      hc->GetContentLength(&contentLength);
+    }
+
+    // Check response code for byte-range requests (seeking, chunk requests).
+    // We don't expect to get a 206 response for a compressed stream, but
+    // double check just to be sure.
+    if (!isCompressed && 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) {
+        startOffset = rangeStart;
+        // 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) {
+          contentLength = std::max(contentLength, rangeTotal);
+        }
+      }
+      acceptsRanges = gotRangeHeader;
+    } else if (responseStatus == HTTP_OK_CODE) {
+      // HTTP_OK_CODE means data will be sent from the start of the stream.
+      startOffset = 0;
+
+      if (aRequestOffset > 0) {
+        // If HTTP_OK_CODE is responded for a non-zero range request, we have
+        // to assume seeking doesn't work.
+        acceptsRanges = false;
+      }
+    }
+    if (aRequestOffset == 0 && contentLength >= 0 &&
+        (responseStatus == HTTP_OK_CODE ||
+         responseStatus == HTTP_PARTIAL_RESPONSE_CODE)) {
+      length = 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. We also can't seek in compressed streams.
+    seekable = !isCompressed && acceptsRanges;
+  } else {
+    // Not an HTTP channel. Assume data will be sent from position zero.
+    startOffset = 0;
+  }
+
+  // Update principals before OnDataAvailable() putting the data in the cache.
+  // This is important, we want to make sure all principals are updated before
+  // any consumer can see the new data.
+  UpdatePrincipal();
+  if (owner->HasError()) {
+    // Updating the principal resulted in an error. Abort the load.
+    CloseChannel();
+    return NS_OK;
+  }
+
+  mCacheStream.NotifyDataStarted(mLoadID, startOffset, seekable, length);
+  mIsTransportSeekable = seekable;
+  if (mFirstReadLength < 0) {
+    mFirstReadLength = length;
+  }
+
+  mSuspendAgent.Delegate(mChannel);
+
+  // Fires an initial progress event.
+  owner->DownloadProgressed();
+
+  nsCOMPtr<nsIThreadRetargetableRequest> retarget;
+  if ((retarget = do_QueryInterface(aRequest))) {
+    // Note this will not always succeed. We need to handle the case where
+    // all resources sharing the same cache might run their data callbacks
+    // on different threads.
+    retarget->RetargetDeliveryTo(mCacheStream.OwnerThread());
+  }
+
+  return NS_OK;
+}
+
+bool ChannelMediaResource::IsTransportSeekable() {
+  MOZ_ASSERT(NS_IsMainThread());
+  // We Report the transport as seekable if we know we will never seek into
+  // the underlying transport. As the MediaCache reads content by block of
+  // BLOCK_SIZE bytes, so the content length is less it will always be fully
+  // read from offset = 0 and we can then always successfully seek within this
+  // buffered content.
+  return mIsTransportSeekable ||
+         (mFirstReadLength > 0 &&
+          mFirstReadLength < MediaCacheStream::BLOCK_SIZE);
+}
+
+nsresult ChannelMediaResource::ParseContentRangeHeader(
+    nsIHttpChannel* aHttpChan, int64_t& aRangeStart, int64_t& aRangeEnd,
+    int64_t& aRangeTotal) const {
+  NS_ENSURE_ARG(aHttpChan);
+
+  nsAutoCString rangeStr;
+  nsresult rv = aHttpChan->GetResponseHeader("Content-Range"_ns, rangeStr);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_FALSE(rangeStr.IsEmpty(), NS_ERROR_ILLEGAL_VALUE);
+
+  auto rangeOrErr = net::ParseContentRangeHeaderString(rangeStr);
+  NS_ENSURE_FALSE(rangeOrErr.isErr(), rangeOrErr.unwrapErr());
+
+  aRangeStart = std::get<0>(rangeOrErr.inspect());
+  aRangeEnd = std::get<1>(rangeOrErr.inspect());
+  aRangeTotal = std::get<2>(rangeOrErr.inspect());
+
+  LOG("Received bytes [%" PRId64 "] to [%" PRId64 "] of [%" PRId64
+      "] 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?");
+  MOZ_DIAGNOSTIC_ASSERT(!mClosed);
+
+  // 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) {
+    Unused << NS_WARN_IF(
+        NS_FAILED(ModifyLoadFlags(loadFlags & ~nsIRequest::LOAD_BACKGROUND)));
+  }
+
+  // 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. It is also possible that the server sends us fewer bytes than
+  // requested. 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.
+  /*
+   * | length |    offset |   reopen |
+   * +--------+-----------+----------+
+   * |     -1 |         0 |      yes |
+   * +--------+-----------+----------+
+   * |     -1 |       > 0 | seekable |
+   * +--------+-----------+----------+
+   * |      0 |         X |       no |
+   * +--------+-----------+----------+
+   * |    > 0 |         0 |      yes |
+   * +--------+-----------+----------+
+   * |    > 0 | != length | seekable |
+   * +--------+-----------+----------+
+   * |    > 0 | == length |       no |
+   */
+  if (aStatus != NS_ERROR_PARSED_DATA_CACHED && aStatus != NS_BINDING_ABORTED) {
+    auto lengthAndOffset = mCacheStream.GetLengthAndOffset();
+    int64_t length = lengthAndOffset.mLength;
+    int64_t offset = lengthAndOffset.mOffset;
+    if ((offset == 0 || mIsTransportSeekable) && offset != length) {
+      // If the stream did close normally, restart the channel if we're either
+      // at the start of the resource, or if the server is seekable and we're
+      // not at the end of stream. We don't restart the stream if we're at the
+      // end because not all web servers handle this case consistently; see:
+      // https://bugzilla.mozilla.org/show_bug.cgi?id=1373618#c36
+      nsresult rv = Seek(offset, false);
+      if (NS_SUCCEEDED(rv)) {
+        return rv;
+      }
+      // Close the streams that failed due to error. This will cause all
+      // client Read and Seek operations on those streams to fail. Blocked
+      // Reads will also be woken up.
+      Close();
+    }
+  }
+
+  mCacheStream.NotifyDataEnded(mLoadID, aStatus);
+  return NS_OK;
+}
+
+nsresult ChannelMediaResource::OnChannelRedirect(nsIChannel* aOld,
+                                                 nsIChannel* aNew,
+                                                 uint32_t aFlags,
+                                                 int64_t aOffset) {
+  // OnChannelRedirect() is followed by OnStartRequest() where we will
+  // call mSuspendAgent.Delegate().
+  mChannel = aNew;
+  return SetupChannelHeaders(aOffset);
+}
+
+nsresult ChannelMediaResource::CopySegmentToCache(
+    nsIInputStream* aInStream, void* aClosure, const char* aFromSegment,
+    uint32_t aToOffset, uint32_t aCount, uint32_t* aWriteCount) {
+  *aWriteCount = aCount;
+  Closure* closure = static_cast<Closure*>(aClosure);
+  MediaCacheStream* cacheStream = &closure->mResource->mCacheStream;
+  if (cacheStream->OwnerThread()->IsOnCurrentThread()) {
+    cacheStream->NotifyDataReceived(
+        closure->mLoadID, aCount,
+        reinterpret_cast<const uint8_t*>(aFromSegment));
+    return NS_OK;
+  }
+
+  RefPtr<ChannelMediaResource> self = closure->mResource;
+  uint32_t loadID = closure->mLoadID;
+  UniquePtr<uint8_t[]> data = MakeUnique<uint8_t[]>(aCount);
+  memcpy(data.get(), aFromSegment, aCount);
+  cacheStream->OwnerThread()->Dispatch(NS_NewRunnableFunction(
+      "MediaCacheStream::NotifyDataReceived",
+      [self, loadID, data = std::move(data), aCount]() {
+        self->mCacheStream.NotifyDataReceived(loadID, aCount, data.get());
+      }));
+
+  return NS_OK;
+}
+
+nsresult ChannelMediaResource::OnDataAvailable(uint32_t aLoadID,
+                                               nsIInputStream* aStream,
+                                               uint32_t aCount) {
+  // This might happen off the main thread.
+  Closure closure{aLoadID, 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;
+}
+
+int64_t ChannelMediaResource::CalculateStreamLength() const {
+  if (!mChannel) {
+    return -1;
+  }
+
+  nsCOMPtr<nsIHttpChannel> hc = do_QueryInterface(mChannel);
+  if (!hc) {
+    return -1;
+  }
+
+  bool succeeded = false;
+  Unused << hc->GetRequestSucceeded(&succeeded);
+  if (!succeeded) {
+    return -1;
+  }
+
+  // We can't determine the length of uncompressed payload.
+  const bool isCompressed = IsPayloadCompressed(hc);
+  if (isCompressed) {
+    return -1;
+  }
+
+  int64_t contentLength = -1;
+  if (NS_FAILED(hc->GetContentLength(&contentLength))) {
+    return -1;
+  }
+
+  uint32_t responseStatus = 0;
+  Unused << hc->GetResponseStatus(&responseStatus);
+  if (responseStatus != HTTP_PARTIAL_RESPONSE_CODE) {
+    return contentLength;
+  }
+
+  // We have an HTTP Byte Range response. The Content-Length is the length
+  // of the response, not the resource. We need to parse the Content-Range
+  // header and extract the range total in order to get the stream length.
+  int64_t rangeStart = 0;
+  int64_t rangeEnd = 0;
+  int64_t rangeTotal = 0;
+  bool gotRangeHeader = NS_SUCCEEDED(
+      ParseContentRangeHeader(hc, rangeStart, rangeEnd, rangeTotal));
+  if (gotRangeHeader && rangeTotal != -1) {
+    contentLength = std::max(contentLength, rangeTotal);
+  }
+  return contentLength;
+}
+
+nsresult ChannelMediaResource::Open(nsIStreamListener** aStreamListener) {
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+  MOZ_ASSERT(aStreamListener);
+  MOZ_ASSERT(mChannel);
+
+  int64_t streamLength =
+      mKnownStreamLength < 0 ? CalculateStreamLength() : mKnownStreamLength;
+  nsresult rv = mCacheStream.Init(streamLength);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  mSharedInfo = new SharedInfo;
+  mSharedInfo->mResources.AppendElement(this);
+
+  mIsLiveStream = streamLength < 0;
+  mListener = new Listener(this, 0, ++mLoadID);
+  *aStreamListener = mListener;
+  NS_ADDREF(*aStreamListener);
+  return NS_OK;
+}
+
+dom::HTMLMediaElement* ChannelMediaResource::MediaElement() const {
+  MOZ_ASSERT(NS_IsMainThread());
+  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
+  MOZ_DIAGNOSTIC_ASSERT(owner);
+  dom::HTMLMediaElement* element = owner->GetMediaElement();
+  MOZ_DIAGNOSTIC_ASSERT(element);
+  return element;
+}
+
+nsresult ChannelMediaResource::OpenChannel(int64_t aOffset) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_DIAGNOSTIC_ASSERT(!mClosed);
+  MOZ_ASSERT(mChannel);
+  MOZ_ASSERT(!mListener, "Listener should have been removed by now");
+
+  mListener = new Listener(this, aOffset, ++mLoadID);
+  nsresult rv = mChannel->SetNotificationCallbacks(mListener.get());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = SetupChannelHeaders(aOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mChannel->AsyncOpen(mListener);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Tell the media element that we are fetching data from a channel.
+  MediaElement()->DownloadResumed();
+
+  return NS_OK;
+}
+
+nsresult ChannelMediaResource::SetupChannelHeaders(int64_t aOffset) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_DIAGNOSTIC_ASSERT(!mClosed);
+
+  // 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(aOffset);
+    rangeString.Append('-');
+    nsresult rv = hc->SetRequestHeader("Range"_ns, rangeString, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Send Accept header for video and audio types only (Bug 489071)
+    MediaElement()->SetRequestHeaders(hc);
+  } else {
+    NS_ASSERTION(aOffset == 0, "Don't know how to seek on this channel type");
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+RefPtr<GenericPromise> ChannelMediaResource::Close() {
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  if (!mClosed) {
+    CloseChannel();
+    mClosed = true;
+    return mCacheStream.Close();
+  }
+  return GenericPromise::CreateAndResolve(true, __func__);
+}
+
+already_AddRefed<nsIPrincipal> ChannelMediaResource::GetCurrentPrincipal() {
+  MOZ_ASSERT(NS_IsMainThread());
+  return do_AddRef(mSharedInfo->mPrincipal);
+}
+
+bool ChannelMediaResource::HadCrossOriginRedirects() {
+  MOZ_ASSERT(NS_IsMainThread());
+  return mSharedInfo->mHadCrossOriginRedirects;
+}
+
+bool ChannelMediaResource::CanClone() {
+  return !mClosed && mCacheStream.IsAvailableForSharing();
+}
+
+already_AddRefed<BaseMediaResource> ChannelMediaResource::CloneData(
+    MediaResourceCallback* aCallback) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(CanClone(), "Stream can't be cloned");
+
+  RefPtr<ChannelMediaResource> resource =
+      new ChannelMediaResource(aCallback, nullptr, mURI, mKnownStreamLength);
+
+  resource->mIsLiveStream = mIsLiveStream;
+  resource->mIsTransportSeekable = mIsTransportSeekable;
+  resource->mSharedInfo = mSharedInfo;
+  mSharedInfo->mResources.AppendElement(resource.get());
+
+  // 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->mCacheStream.InitAsClone(&mCacheStream);
+  return resource.forget();
+}
+
+void ChannelMediaResource::CloseChannel() {
+  NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+  // Revoking listener should be done before canceling the channel, because
+  // canceling the channel might cause the input stream to release its buffer.
+  // If we don't do revoke first, it's possible that `OnDataAvailable` would be
+  // called later and then incorrectly access that released buffer.
+  if (mListener) {
+    mListener->Revoke();
+    mListener = nullptr;
+  }
+
+  if (mChannel) {
+    mSuspendAgent.Revoke();
+    // 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");
+  return mCacheStream.ReadAt(aOffset, aBuffer, aCount, aBytes);
+}
+
+void ChannelMediaResource::ThrottleReadahead(bool bThrottle) {
+  mCacheStream.ThrottleReadahead(bThrottle);
+}
+
+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");
+
+  if (mClosed) {
+    // Nothing to do when we are closed.
+    return;
+  }
+
+  dom::HTMLMediaElement* element = MediaElement();
+
+  if (mChannel && aCloseImmediately && mIsTransportSeekable) {
+    CloseChannel();
+  }
+
+  if (mSuspendAgent.Suspend()) {
+    element->DownloadSuspended();
+  }
+}
+
+void ChannelMediaResource::Resume() {
+  NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+
+  if (mClosed) {
+    // Nothing to do when we are closed.
+    return;
+  }
+
+  dom::HTMLMediaElement* element = MediaElement();
+
+  if (mSuspendAgent.Resume()) {
+    if (mChannel) {
+      // Just wake up our existing channel
+      element->DownloadResumed();
+    } else {
+      mCacheStream.NotifyResume();
+    }
+  }
+}
+
+nsresult ChannelMediaResource::RecreateChannel() {
+  MOZ_DIAGNOSTIC_ASSERT(!mClosed);
+
+  nsLoadFlags loadFlags = nsICachingChannel::LOAD_BYPASS_LOCAL_CACHE_IF_BUSY |
+                          (mLoadInBackground ? nsIRequest::LOAD_BACKGROUND : 0);
+
+  dom::HTMLMediaElement* element = MediaElement();
+
+  nsCOMPtr<nsILoadGroup> loadGroup = element->GetDocumentLoadGroup();
+  NS_ENSURE_TRUE(loadGroup, NS_ERROR_NULL_POINTER);
+
+  nsSecurityFlags securityFlags =
+      element->ShouldCheckAllowOrigin()
+          ? nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT
+          : nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT;
+
+  if (element->GetCORSMode() == CORS_USE_CREDENTIALS) {
+    securityFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE;
+  }
+
+  MOZ_ASSERT(element->IsAnyOfHTMLElements(nsGkAtoms::audio, nsGkAtoms::video));
+  nsContentPolicyType contentPolicyType =
+      element->IsHTMLElement(nsGkAtoms::audio)
+          ? nsIContentPolicy::TYPE_INTERNAL_AUDIO
+          : nsIContentPolicy::TYPE_INTERNAL_VIDEO;
+
+  // If element has 'triggeringprincipal' attribute, we will use the value as
+  // triggeringPrincipal for the channel, otherwise it will default to use
+  // aElement->NodePrincipal().
+  // This function returns true when element has 'triggeringprincipal', so if
+  // setAttrs is true we will override the origin attributes on the channel
+  // later.
+  nsCOMPtr<nsIPrincipal> triggeringPrincipal;
+  bool setAttrs = nsContentUtils::QueryTriggeringPrincipal(
+      element, getter_AddRefs(triggeringPrincipal));
+
+  nsresult rv = NS_NewChannelWithTriggeringPrincipal(
+      getter_AddRefs(mChannel), mURI, element, triggeringPrincipal,
+      securityFlags, contentPolicyType,
+      nullptr,  // aPerformanceStorage
+      loadGroup,
+      nullptr,  // aCallbacks
+      loadFlags);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
+  if (setAttrs) {
+    // The function simply returns NS_OK, so we ignore the return value.
+    Unused << loadInfo->SetOriginAttributes(
+        triggeringPrincipal->OriginAttributesRef());
+  }
+
+  Unused << loadInfo->SetIsMediaRequest(true);
+
+  nsCOMPtr<nsIClassOfService> cos(do_QueryInterface(mChannel));
+  if (cos) {
+    // Unconditionally disable throttling since we want the media to fluently
+    // play even when we switch the tab to background.
+    cos->AddClassFlags(nsIClassOfService::DontThrottle);
+  }
+
+  return rv;
+}
+
+void ChannelMediaResource::CacheClientNotifyDataReceived() {
+  mCallback->AbstractMainThread()->Dispatch(NewRunnableMethod(
+      "MediaResourceCallback::NotifyDataArrived", mCallback.get(),
+      &MediaResourceCallback::NotifyDataArrived));
+}
+
+void ChannelMediaResource::CacheClientNotifyDataEnded(nsresult aStatus) {
+  mCallback->AbstractMainThread()->Dispatch(NS_NewRunnableFunction(
+      "ChannelMediaResource::CacheClientNotifyDataEnded",
+      [self = RefPtr<ChannelMediaResource>(this), aStatus]() {
+        if (NS_SUCCEEDED(aStatus)) {
+          self->mIsLiveStream = false;
+        }
+        self->mCallback->NotifyDataEnded(aStatus);
+      }));
+}
+
+void ChannelMediaResource::CacheClientNotifyPrincipalChanged() {
+  NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
+
+  mCallback->NotifyPrincipalChanged();
+}
+
+void ChannelMediaResource::UpdatePrincipal() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mChannel);
+  nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
+  if (!secMan) {
+    return;
+  }
+  bool hadData = mSharedInfo->mPrincipal != nullptr;
+  // Channels created from a media element (in RecreateChannel() or
+  // HTMLMediaElement::ChannelLoader) do not have SANDBOXED_ORIGIN set in the
+  // LoadInfo.  Document loads for a sandboxed iframe, however, may have
+  // SANDBOXED_ORIGIN set.  Ignore sandboxing so that on such loads the result
+  // principal is not replaced with a null principal but describes the source
+  // of the data and is the same as would be obtained from a load from the
+  // media host element.
+  nsCOMPtr<nsIPrincipal> principal;
+  secMan->GetChannelResultPrincipalIfNotSandboxed(mChannel,
+                                                  getter_AddRefs(principal));
+  if (nsContentUtils::CombineResourcePrincipals(&mSharedInfo->mPrincipal,
+                                                principal)) {
+    for (auto* r : mSharedInfo->mResources) {
+      r->CacheClientNotifyPrincipalChanged();
+    }
+    if (!mChannel) {  // Sometimes cleared during NotifyPrincipalChanged()
+      return;
+    }
+  }
+  nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
+  auto mode = loadInfo->GetSecurityMode();
+  if (mode != nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT) {
+    MOZ_ASSERT(
+        mode == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT ||
+            mode == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+        "no-cors request");
+    MOZ_ASSERT(!hadData || !mChannel->IsDocument(),
+               "Only the initial load may be a document load");
+    bool finalResponseIsOpaque =
+        // NS_GetFinalChannelURI() and GetChannelResultPrincipal() return the
+        // original request URI for null-origin Responses from ServiceWorker,
+        // in which case the URI does not necessarily indicate the real source
+        // of data.  Such null-origin Responses have Basic LoadTainting, and
+        // so can be distinguished from true cross-origin responses when the
+        // channel is not a document load.
+        //
+        // When the channel is a document load, LoadTainting indicates opacity
+        // wrt the parent document and so does not indicate whether the
+        // response is cross-origin wrt to the media element.  However,
+        // ServiceWorkers for document loads are always same-origin with the
+        // channel URI and so there is no need to distinguish null-origin
+        // ServiceWorker responses to document loads.
+        //
+        // CORS filtered Responses from ServiceWorker also cannot be mixed
+        // with no-cors cross-origin responses.
+        (mChannel->IsDocument() ||
+         loadInfo->GetTainting() == LoadTainting::Opaque) &&
+        // Although intermediate cross-origin redirects back to URIs with
+        // loadingPrincipal will have LoadTainting::Opaque and will taint the
+        // media element, they are not considered opaque when verifying
+        // network responses; they can be mixed with non-opaque responses from
+        // subsequent loads on the same-origin finalURI.
+        !nsContentUtils::CheckMayLoad(MediaElement()->NodePrincipal(), mChannel,
+                                      /*allowIfInheritsPrincipal*/ true);
+    if (!hadData) {  // First response with data
+      mSharedInfo->mFinalResponsesAreOpaque = finalResponseIsOpaque;
+    } else if (mSharedInfo->mFinalResponsesAreOpaque != finalResponseIsOpaque) {
+      for (auto* r : mSharedInfo->mResources) {
+        r->mCallback->NotifyNetworkError(MediaResult(
+            NS_ERROR_CONTENT_BLOCKED, "opaque and non-opaque responses"));
+      }
+      // Our caller, OnStartRequest() will CloseChannel() on discovering the
+      // error, so no data will be read from the channel.
+      return;
+    }
+  }
+  // ChannelMediaResource can recreate the channel. When this happens, we don't
+  // want to overwrite mHadCrossOriginRedirects because the new channel could
+  // skip intermediate redirects.
+  if (!mSharedInfo->mHadCrossOriginRedirects) {
+    nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(mChannel);
+    if (timedChannel) {
+      bool allRedirectsSameOrigin = false;
+      mSharedInfo->mHadCrossOriginRedirects =
+          NS_SUCCEEDED(timedChannel->GetAllRedirectsSameOrigin(
+              &allRedirectsSameOrigin)) &&
+          !allRedirectsSameOrigin;
+    }
+  }
+}
+
+void ChannelMediaResource::CacheClientNotifySuspendedStatusChanged(
+    bool aSuspended) {
+  mCallback->AbstractMainThread()->Dispatch(NewRunnableMethod<bool>(
+      "MediaResourceCallback::NotifySuspendedStatusChanged", mCallback.get(),
+      &MediaResourceCallback::NotifySuspendedStatusChanged, aSuspended));
+}
+
+nsresult ChannelMediaResource::Seek(int64_t aOffset, bool aResume) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mClosed) {
+    // Nothing to do when we are closed.
+    return NS_OK;
+  }
+
+  LOG("Seek requested for aOffset [%" PRId64 "]", aOffset);
+
+  CloseChannel();
+
+  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(aOffset);
+}
+
+void ChannelMediaResource::CacheClientSeek(int64_t aOffset, bool aResume) {
+  RefPtr<ChannelMediaResource> self = this;
+  nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(
+      "ChannelMediaResource::Seek", [self, aOffset, aResume]() {
+        nsresult rv = self->Seek(aOffset, aResume);
+        if (NS_FAILED(rv)) {
+          // Close the streams that failed due to error. This will cause all
+          // client Read and Seek operations on those streams to fail. Blocked
+          // Reads will also be woken up.
+          self->Close();
+        }
+      });
+  mCallback->AbstractMainThread()->Dispatch(r.forget());
+}
+
+void ChannelMediaResource::CacheClientSuspend() {
+  mCallback->AbstractMainThread()->Dispatch(
+      NewRunnableMethod<bool>("ChannelMediaResource::Suspend", this,
+                              &ChannelMediaResource::Suspend, false));
+}
+
+void ChannelMediaResource::CacheClientResume() {
+  mCallback->AbstractMainThread()->Dispatch(NewRunnableMethod(
+      "ChannelMediaResource::Resume", this, &ChannelMediaResource::Resume));
+}
+
+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);
+}
+
+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) {
+  return mCacheStream.GetDownloadRate(aIsReliable);
+}
+
+int64_t ChannelMediaResource::GetLength() { return mCacheStream.GetLength(); }
+
+void ChannelMediaResource::GetDebugInfo(dom::MediaResourceDebugInfo& aInfo) {
+  mCacheStream.GetDebugInfo(aInfo.mCacheStream);
+}
+
+// ChannelSuspendAgent
+
+bool ChannelSuspendAgent::Suspend() {
+  MOZ_ASSERT(NS_IsMainThread());
+  SuspendInternal();
+  if (++mSuspendCount == 1) {
+    mCacheStream.NotifyClientSuspended(true);
+    return true;
+  }
+  return false;
+}
+
+void ChannelSuspendAgent::SuspendInternal() {
+  MOZ_ASSERT(NS_IsMainThread());
+  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(NS_IsMainThread());
+  MOZ_ASSERT(IsSuspended(), "Resume without suspend!");
+
+  if (--mSuspendCount == 0) {
+    if (mChannel && mIsChannelSuspended) {
+      mChannel->Resume();
+      mIsChannelSuspended = false;
+    }
+    mCacheStream.NotifyClientSuspended(false);
+    return true;
+  }
+  return false;
+}
+
+void ChannelSuspendAgent::Delegate(nsIChannel* aChannel) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aChannel);
+  MOZ_ASSERT(!mChannel, "The previous channel not closed.");
+  MOZ_ASSERT(!mIsChannelSuspended);
+
+  mChannel = aChannel;
+  // Ensure the suspend status of the channel matches our suspend count.
+  if (IsSuspended()) {
+    SuspendInternal();
+  }
+}
+
+void ChannelSuspendAgent::Revoke() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mChannel) {
+    // Channel already revoked. Nothing to do.
+    return;
+  }
+
+  // Before closing the channel, it needs 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() {
+  MOZ_ASSERT(NS_IsMainThread());
+  return (mSuspendCount > 0);
+}
+
+}  // namespace mozilla
+
+#undef LOG