Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 273 insertions, 0 deletions

diff --git a/dom/media/ChannelMediaResource.h b/dom/media/ChannelMediaResource.h
new file mode 100644
index 0000000000..892dca1de0
--- /dev/null
+++ b/dom/media/ChannelMediaResource.h
@@ -0,0 +1,273 @@
+/* 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/. */
+
+#ifndef mozilla_dom_media_ChannelMediaResource_h
+#define mozilla_dom_media_ChannelMediaResource_h
+
+#include "BaseMediaResource.h"
+#include "MediaCache.h"
+#include "mozilla/Mutex.h"
+#include "nsIChannelEventSink.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIThreadRetargetableStreamListener.h"
+
+class nsIHttpChannel;
+
+namespace mozilla {
+
+/**
+ * This class is responsible for managing the suspend count and report suspend
+ * status of channel.
+ **/
+class ChannelSuspendAgent {
+ public:
+  explicit ChannelSuspendAgent(MediaCacheStream& aCacheStream)
+      : mCacheStream(aCacheStream) {}
+
+  // True when the channel has been suspended or needs to be suspended.
+  bool IsSuspended();
+
+  // Return true when the channel is logically suspended, i.e. the suspend
+  // count goes from 0 to 1.
+  bool Suspend();
+
+  // Return true only when the suspend count is equal to zero.
+  bool Resume();
+
+  // Tell the agent to manage the suspend status of the channel.
+  void Delegate(nsIChannel* aChannel);
+  // Stop the management of the suspend status of the channel.
+  void Revoke();
+
+ private:
+  // Only suspends channel but not changes the suspend count.
+  void SuspendInternal();
+
+  nsIChannel* mChannel = nullptr;
+  MediaCacheStream& mCacheStream;
+  uint32_t mSuspendCount = 0;
+  bool mIsChannelSuspended = false;
+};
+
+DDLoggedTypeDeclNameAndBase(ChannelMediaResource, BaseMediaResource);
+
+/**
+ * This is the MediaResource implementation that wraps Necko channels.
+ * Much of its functionality is actually delegated to MediaCache via
+ * an underlying MediaCacheStream.
+ *
+ * All synchronization is performed by MediaCacheStream; all off-main-
+ * thread operations are delegated directly to that object.
+ */
+class ChannelMediaResource
+    : public BaseMediaResource,
+      public DecoderDoctorLifeLogger<ChannelMediaResource> {
+  // Store information shared among resources. Main thread only.
+  struct SharedInfo {
+    NS_INLINE_DECL_REFCOUNTING(SharedInfo);
+
+    nsTArray<ChannelMediaResource*> mResources;
+    // Null if there is not yet any data from any origin.
+    nsCOMPtr<nsIPrincipal> mPrincipal;
+    // Meaningful only when mPrincipal is non-null,
+    // unaffected by intermediate cross-origin redirects.
+    bool mFinalResponsesAreOpaque = false;
+
+    bool mHadCrossOriginRedirects = false;
+
+   private:
+    ~SharedInfo() = default;
+  };
+  RefPtr<SharedInfo> mSharedInfo;
+
+ public:
+  ChannelMediaResource(MediaResourceCallback* aDecoder, nsIChannel* aChannel,
+                       nsIURI* aURI, int64_t aStreamLength,
+                       bool aIsPrivateBrowsing = false);
+  ~ChannelMediaResource();
+
+  // These are called on the main thread by MediaCache. These must
+  // not block or grab locks, because the media cache is holding its lock.
+  // Notify that data is available from the cache. This can happen even
+  // if this stream didn't read any data, since another stream might have
+  // received data for the same resource.
+  void CacheClientNotifyDataReceived();
+  // Notify that we reached the end of the stream. This can happen even
+  // if this stream didn't read any data, since another stream might have
+  // received data for the same resource.
+  void CacheClientNotifyDataEnded(nsresult aStatus);
+  // Notify that the principal for the cached resource changed.
+  void CacheClientNotifyPrincipalChanged();
+  // Notify the decoder that the cache suspended status changed.
+  void CacheClientNotifySuspendedStatusChanged(bool aSuspended);
+
+  // These are called on the main thread by MediaCache. These shouldn't block,
+  // but they may grab locks --- the media cache is not holding its lock
+  // when these are called.
+  // Start a new load at the given aOffset. The old load is cancelled
+  // and no more data from the old load will be notified via
+  // MediaCacheStream::NotifyDataReceived/Ended.
+  void CacheClientSeek(int64_t aOffset, bool aResume);
+  // Suspend the current load since data is currently not wanted
+  void CacheClientSuspend();
+  // Resume the current load since data is wanted again
+  void CacheClientResume();
+
+  bool IsSuspended();
+
+  void ThrottleReadahead(bool bThrottle) override;
+
+  // Main thread
+  nsresult Open(nsIStreamListener** aStreamListener) override;
+  RefPtr<GenericPromise> Close() override;
+  void Suspend(bool aCloseImmediately) override;
+  void Resume() override;
+  already_AddRefed<nsIPrincipal> GetCurrentPrincipal() override;
+  bool HadCrossOriginRedirects() override;
+  bool CanClone() override;
+  already_AddRefed<BaseMediaResource> CloneData(
+      MediaResourceCallback* aDecoder) override;
+  nsresult ReadFromCache(char* aBuffer, int64_t aOffset,
+                         uint32_t aCount) override;
+
+  // Other thread
+  void SetReadMode(MediaCacheStream::ReadMode aMode) override;
+  void SetPlaybackRate(uint32_t aBytesPerSecond) override;
+  nsresult ReadAt(int64_t offset, char* aBuffer, uint32_t aCount,
+                  uint32_t* aBytes) override;
+  // Data stored in IO&lock-encumbered MediaCacheStream, caching recommended.
+  bool ShouldCacheReads() override { return true; }
+
+  // Any thread
+  void Pin() override;
+  void Unpin() override;
+  double GetDownloadRate(bool* aIsReliable) override;
+  int64_t GetLength() override;
+  int64_t GetNextCachedData(int64_t aOffset) override;
+  int64_t GetCachedDataEnd(int64_t aOffset) override;
+  bool IsDataCachedToEndOfResource(int64_t aOffset) override;
+  bool IsTransportSeekable() override;
+  bool IsLiveStream() const override { return mIsLiveStream; }
+
+  size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override {
+    // Might be useful to track in the future:
+    //   - mListener (seems minor)
+    size_t size = BaseMediaResource::SizeOfExcludingThis(aMallocSizeOf);
+    size += mCacheStream.SizeOfExcludingThis(aMallocSizeOf);
+
+    return size;
+  }
+
+  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+  void GetDebugInfo(dom::MediaResourceDebugInfo& aInfo) override;
+
+  class Listener final : public nsIStreamListener,
+                         public nsIInterfaceRequestor,
+                         public nsIChannelEventSink,
+                         public nsIThreadRetargetableStreamListener {
+    ~Listener() = default;
+
+   public:
+    Listener(ChannelMediaResource* aResource, int64_t aOffset, uint32_t aLoadID)
+        : mMutex("Listener.mMutex"),
+          mResource(aResource),
+          mOffset(aOffset),
+          mLoadID(aLoadID) {}
+
+    NS_DECL_THREADSAFE_ISUPPORTS
+    NS_DECL_NSIREQUESTOBSERVER
+    NS_DECL_NSISTREAMLISTENER
+    NS_DECL_NSICHANNELEVENTSINK
+    NS_DECL_NSIINTERFACEREQUESTOR
+    NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
+
+    void Revoke();
+
+   private:
+    Mutex mMutex MOZ_UNANNOTATED;
+    // mResource should only be modified on the main thread with the lock.
+    // So it can be read without lock on the main thread or on other threads
+    // with the lock.
+    RefPtr<ChannelMediaResource> mResource;
+
+    const int64_t mOffset;
+    const uint32_t mLoadID;
+  };
+  friend class Listener;
+
+  nsresult GetCachedRanges(MediaByteRangeSet& aRanges) override;
+
+ protected:
+  nsresult Seek(int64_t aOffset, bool aResume);
+
+  // These are called on the main thread by Listener.
+  nsresult OnStartRequest(nsIRequest* aRequest, int64_t aRequestOffset);
+  nsresult OnStopRequest(nsIRequest* aRequest, nsresult aStatus);
+  nsresult OnDataAvailable(uint32_t aLoadID, nsIInputStream* aStream,
+                           uint32_t aCount);
+  nsresult OnChannelRedirect(nsIChannel* aOld, nsIChannel* aNew,
+                             uint32_t aFlags, int64_t aOffset);
+
+  // Use only before MediaDecoder shutdown.  Main thread only.
+  dom::HTMLMediaElement* MediaElement() const;
+  // Opens the channel, using an HTTP byte range request to start at aOffset
+  // if possible. Main thread only.
+  nsresult OpenChannel(int64_t aOffset);
+  nsresult RecreateChannel();
+  // Add headers to HTTP request. Main thread only.
+  nsresult SetupChannelHeaders(int64_t aOffset);
+  // Closes the channel. Main thread only.
+  void CloseChannel();
+  // Update the principal for the resource. Main thread only.
+  void UpdatePrincipal();
+
+  // Parses 'Content-Range' header and returns results via parameters.
+  // Returns error if header is not available, values are not parse-able or
+  // values are out of range.
+  nsresult ParseContentRangeHeader(nsIHttpChannel* aHttpChan,
+                                   int64_t& aRangeStart, int64_t& aRangeEnd,
+                                   int64_t& aRangeTotal) const;
+
+  // Calculates the length of the resource using HTTP headers, if this
+  // is an HTTP channel. Returns -1 on failure, or for non HTTP channels.
+  int64_t CalculateStreamLength() const;
+
+  struct Closure {
+    uint32_t mLoadID;
+    ChannelMediaResource* mResource;
+  };
+
+  static nsresult CopySegmentToCache(nsIInputStream* aInStream, void* aClosure,
+                                     const char* aFromSegment,
+                                     uint32_t aToOffset, uint32_t aCount,
+                                     uint32_t* aWriteCount);
+
+  // Main thread access only
+  // True if Close() has been called.
+  bool mClosed = false;
+  // The last reported seekability state for the underlying channel
+  bool mIsTransportSeekable = false;
+  // Length of the content first reported.
+  int64_t mFirstReadLength = -1;
+  RefPtr<Listener> mListener;
+  // A mono-increasing integer to uniquely identify the channel we are loading.
+  uint32_t mLoadID = 0;
+  bool mIsLiveStream = false;
+
+  // Any thread access
+  MediaCacheStream mCacheStream;
+
+  ChannelSuspendAgent mSuspendAgent;
+
+  // The size of the stream if known at construction time (such as with blob)
+  const int64_t mKnownStreamLength;
+};
+
+}  // namespace mozilla
+
+#endif  // mozilla_dom_media_ChannelMediaResource_h