gecko-dev/dom/media/ChannelMediaResource.cpp

/* 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) {
  MOZ_ASSERT(NS_IsMainThread());
  if (!mResource) return NS_OK;
  return mResource->OnStartRequest(aRequest, mOffset);
}

nsresult ChannelMediaResource::Listener::OnStopRequest(nsIRequest* aRequest,
                                                       nsresult aStatus) {
  MOZ_ASSERT(NS_IsMainThread());
  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;
  {
    MutexAutoLock 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) {
  MOZ_ASSERT(NS_IsMainThread());

  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; }

nsresult ChannelMediaResource::Listener::GetInterface(const nsIID& aIID,
                                                      void** aResult) {
  return QueryInterface(aIID, aResult);
}

void ChannelMediaResource::Listener::Revoke() {
  MOZ_ASSERT(NS_IsMainThread());
  MutexAutoLock 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 (Preferences::GetBool("media.omt_data_delivery.enabled", false) &&
      (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;
}

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.
  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
  MOZ_DIAGNOSTIC_ASSERT(owner);
  dom::HTMLMediaElement* element = owner->GetMediaElement();
  MOZ_DIAGNOSTIC_ASSERT(element);
  element->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)
    MediaDecoderOwner* owner = mCallback->GetMediaOwner();
    MOZ_DIAGNOSTIC_ASSERT(owner);
    dom::HTMLMediaElement* element = owner->GetMediaElement();
    MOZ_DIAGNOSTIC_ASSERT(element);
    element->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;
  }

  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
  MOZ_DIAGNOSTIC_ASSERT(owner);
  dom::HTMLMediaElement* element = owner->GetMediaElement();
  MOZ_DIAGNOSTIC_ASSERT(element);

  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;
  }

  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
  MOZ_DIAGNOSTIC_ASSERT(owner);
  dom::HTMLMediaElement* element = owner->GetMediaElement();
  MOZ_DIAGNOSTIC_ASSERT(element);

  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);

  MediaDecoderOwner* owner = mCallback->GetMediaOwner();
  MOZ_DIAGNOSTIC_ASSERT(owner);
  dom::HTMLMediaElement* element = owner->GetMediaElement();
  MOZ_DIAGNOSTIC_ASSERT(element);

  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;
  nsCOMPtr<nsIPrincipal> principal;
  secMan->GetChannelResultPrincipal(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");
    bool finalResponseIsOpaque =
        // GetChannelResultPrincipal() returns the original request URL for
        // null-origin Responses from ServiceWorker, in which case the URL
        // does not indicate the real source of data.  Such null-origin
        // Responses have Basic LoadTainting.  CORS filtered Responses from
        // ServiceWorker also cannot be mixed with no-cors cross-origin
        // responses.
        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(loadInfo->GetLoadingPrincipal(), 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