Bug 1800882 - Implement HTMLVideoElement.requestVideoFrameCallback. r=webidl,media-playback-reviewers,emilio,ErichDonGubler,padenot

See https://wicg.github.io/video-rvfc/ for standard details.

Differential Revision: https://phabricator.services.mozilla.com/D216159

Author: ashleyz

dom/base/AnimationFrameProvider.cpp

@@ -7,72 +7,63 @@
 #ifndef mozilla_dom_AnimationFrameProvider_h
 #define mozilla_dom_AnimationFrameProvider_h
 
+#include "MainThreadUtils.h"
+#include "mozilla/Assertions.h"
 #include "mozilla/dom/AnimationFrameProviderBinding.h"
-#include "mozilla/HashTable.h"
-#include "mozilla/RefPtr.h"
-#include "nsTArray.h"
+#include "mozilla/dom/HTMLVideoElement.h"
+#include "mozilla/dom/RequestCallbackManager.h"
 
 namespace mozilla::dom {
 
-struct FrameRequest {
-  FrameRequest(FrameRequestCallback& aCallback, uint32_t aHandle);
-  ~FrameRequest();
+using FrameRequest = RequestCallbackEntry<FrameRequestCallback>;
+using FrameRequestManagerBase = RequestCallbackManager<FrameRequestCallback>;
 
-  // Comparator operators to allow RemoveElementSorted with an
-  // integer argument on arrays of FrameRequest
-  bool operator==(uint32_t aHandle) const { return mHandle == aHandle; }
-  bool operator<(uint32_t aHandle) const { return mHandle < aHandle; }
-
-  RefPtr<FrameRequestCallback> mCallback;
-  uint32_t mHandle;
-};
-
-class FrameRequestManager {
+class FrameRequestManager final : public FrameRequestManagerBase {
  public:
   FrameRequestManager() = default;
   ~FrameRequestManager() = default;
 
-  nsresult Schedule(FrameRequestCallback& aCallback, uint32_t* aHandle);
-  bool Cancel(uint32_t aHandle);
+  using FrameRequestManagerBase::Cancel;
+  using FrameRequestManagerBase::Schedule;
+  using FrameRequestManagerBase::Take;
 
-  bool IsEmpty() const { return mCallbacks.IsEmpty(); }
-
-  bool IsCanceled(uint32_t aHandle) const {
-    return !mCanceledCallbacks.empty() && mCanceledCallbacks.has(aHandle);
+  void Schedule(HTMLVideoElement* aElement) {
+    if (!mVideoCallbacks.Contains(aElement)) {
+      mVideoCallbacks.AppendElement(aElement);
+    }
   }
 
-  void Take(nsTArray<FrameRequest>& aCallbacks) {
-    aCallbacks = std::move(mCallbacks);
-    mCanceledCallbacks.clear();
+  bool Cancel(HTMLVideoElement* aElement) {
+    return mVideoCallbacks.RemoveElement(aElement);
   }
 
-  void Unlink();
+  bool IsEmpty() const {
+    return FrameRequestManagerBase::IsEmpty() && mVideoCallbacks.IsEmpty();
+  }
 
-  void Traverse(nsCycleCollectionTraversalCallback& aCB);
+  void Take(nsTArray<RefPtr<HTMLVideoElement>>& aVideoCallbacks) {
+    MOZ_ASSERT(NS_IsMainThread());
+    aVideoCallbacks = std::move(mVideoCallbacks);
+  }
 
- private:
-  nsTArray<FrameRequest> mCallbacks;
+  void Unlink() {
+    FrameRequestManagerBase::Unlink();
+    mVideoCallbacks.Clear();
+  }
 
-  // The set of frame request callbacks that were canceled but which we failed
-  // to find in mFrameRequestCallbacks.
-  HashSet<uint32_t> mCanceledCallbacks;
+  void Traverse(nsCycleCollectionTraversalCallback& aCB) {
+    FrameRequestManagerBase::Traverse(aCB);
+    for (auto& i : mVideoCallbacks) {
+      NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(
+          aCB, "FrameRequestManager::mVideoCallbacks[i]");
+      aCB.NoteXPCOMChild(ToSupports(i));
+    }
+  }
 
-  /**
-   * The current frame request callback handle
-   */
-  uint32_t mCallbackCounter = 0;
+ private:
+  nsTArray<RefPtr<HTMLVideoElement>> mVideoCallbacks;
 };
 
-inline void ImplCycleCollectionUnlink(FrameRequestManager& aField) {
-  aField.Unlink();
-}
-
-inline void ImplCycleCollectionTraverse(
-    nsCycleCollectionTraversalCallback& aCallback, FrameRequestManager& aField,
-    const char* aName, uint32_t aFlags) {
-  aField.Traverse(aCallback);
-}
-
 }  // namespace mozilla::dom
 
 #endif

dom/base/AnimationFrameProvider.h

@@ -7159,6 +7159,12 @@ void Document::MaybeScheduleFrameRequestCallbacks() {
   rd->EnsureFrameRequestCallbacksHappen();
 }
 
+void Document::TakeVideoFrameRequestCallbacks(
+    nsTArray<RefPtr<HTMLVideoElement>>& aVideoCallbacks) {
+  MOZ_ASSERT(aVideoCallbacks.IsEmpty());
+  mFrameRequestManager.Take(aVideoCallbacks);
+}
+
 void Document::TakeFrameRequestCallbacks(nsTArray<FrameRequest>& aCallbacks) {
   MOZ_ASSERT(aCallbacks.IsEmpty());
   mFrameRequestManager.Take(aCallbacks);
@@ -13692,6 +13698,18 @@ bool Document::IsCanceledFrameRequestCallback(uint32_t aHandle) const {
   return mFrameRequestManager.IsCanceled(aHandle);
 }
 
+void Document::ScheduleVideoFrameCallbacks(HTMLVideoElement* aElement) {
+  const bool wasEmpty = mFrameRequestManager.IsEmpty();
+  mFrameRequestManager.Schedule(aElement);
+  if (wasEmpty) {
+    MaybeScheduleFrameRequestCallbacks();
+  }
+}
+
+void Document::CancelVideoFrameCallbacks(HTMLVideoElement* aElement) {
+  mFrameRequestManager.Cancel(aElement);
+}
+
 nsresult Document::GetStateObject(JS::MutableHandle<JS::Value> aState) {
   // Get the document's current state object. This is the object backing both
   // history.state and popStateEvent.state.

dom/base/Document.cpp

@@ -254,6 +254,7 @@ class HTMLInputElement;
 class HTMLMetaElement;
 class HTMLDialogElement;
 class HTMLSharedElement;
+class HTMLVideoElement;
 class HTMLImageElement;
 struct LifecycleCallbackArgs;
 class Link;
@@ -3047,13 +3048,23 @@ class Document : public nsINode,
                                         uint32_t* aHandle);
   void CancelFrameRequestCallback(uint32_t aHandle);
 
+  void ScheduleVideoFrameCallbacks(HTMLVideoElement* aElement);
+  void CancelVideoFrameCallbacks(HTMLVideoElement* aElement);
+
   /**
    * Returns true if the handle refers to a callback that was canceled that
    * we did not find in our list of callbacks (e.g. because it is one of those
    * in the set of callbacks currently queued to be run).
    */
   bool IsCanceledFrameRequestCallback(uint32_t aHandle) const;
 
+  /**
+   * Put this document's video frame request callbacks into the provided
+   * list, and forget about them.
+   */
+  void TakeVideoFrameRequestCallbacks(
+      nsTArray<RefPtr<HTMLVideoElement>>& aVideoCallbacks);
+
   /**
    * Put this document's frame request callbacks into the provided
    * list, and forget about them.

dom/base/Document.h

@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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_RequestCallbackManager_h
+#define mozilla_dom_RequestCallbackManager_h
+
+#include <limits>
+#include "mozilla/HashTable.h"
+#include "mozilla/RefPtr.h"
+#include "nsTArray.h"
+#include "nsThreadUtils.h"
+
+namespace mozilla::dom {
+
+template <typename RequestCallback>
+struct RequestCallbackEntry {
+  RequestCallbackEntry(RequestCallback& aCallback, uint32_t aHandle)
+      : mCallback(&aCallback), mHandle(aHandle) {
+    LogTaskBase<RequestCallback>::LogDispatch(mCallback);
+  }
+
+  ~RequestCallbackEntry() = default;
+
+  // Comparator operators to allow RemoveElementSorted with an
+  // integer argument on arrays of RequestCallback
+  bool operator==(uint32_t aHandle) const { return mHandle == aHandle; }
+  bool operator<(uint32_t aHandle) const { return mHandle < aHandle; }
+
+  RefPtr<RequestCallback> mCallback;
+  uint32_t mHandle;
+};
+
+template <typename RequestCallback>
+class RequestCallbackManager {
+ public:
+  RequestCallbackManager() = default;
+  ~RequestCallbackManager() = default;
+
+  nsresult Schedule(RequestCallback& aCallback, uint32_t* aHandle) {
+    if (mCallbackCounter == std::numeric_limits<uint32_t>::max()) {
+      // Can't increment without overflowing; bail out
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+    uint32_t newHandle = ++mCallbackCounter;
+
+    mCallbacks.AppendElement(RequestCallbackEntry(aCallback, newHandle));
+
+    *aHandle = newHandle;
+    return NS_OK;
+  }
+
+  bool Cancel(uint32_t aHandle) {
+    // mCallbacks is stored sorted by handle
+    if (mCallbacks.RemoveElementSorted(aHandle)) {
+      return true;
+    }
+
+    Unused << mCanceledCallbacks.put(aHandle);
+    return false;
+  }
+
+  bool IsEmpty() const { return mCallbacks.IsEmpty(); }
+
+  bool IsCanceled(uint32_t aHandle) const {
+    return !mCanceledCallbacks.empty() && mCanceledCallbacks.has(aHandle);
+  }
+
+  void Take(nsTArray<RequestCallbackEntry<RequestCallback>>& aCallbacks) {
+    aCallbacks = std::move(mCallbacks);
+    mCanceledCallbacks.clear();
+  }
+
+  void Unlink() { mCallbacks.Clear(); }
+
+  void Traverse(nsCycleCollectionTraversalCallback& aCB) {
+    for (auto& i : mCallbacks) {
+      NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(
+          aCB, "RequestCallbackManager::mCallbacks[i]");
+      aCB.NoteXPCOMChild(i.mCallback);
+    }
+  }
+
+ private:
+  nsTArray<RequestCallbackEntry<RequestCallback>> mCallbacks;
+
+  // The set of frame request callbacks that were canceled but which we failed
+  // to find in mRequestCallbacks.
+  HashSet<uint32_t> mCanceledCallbacks;
+
+  /**
+   * The current frame request callback handle
+   */
+  uint32_t mCallbackCounter = 0;
+};
+
+template <class RequestCallback>
+inline void ImplCycleCollectionUnlink(
+    RequestCallbackManager<RequestCallback>& aField) {
+  aField.Unlink();
+}
+
+template <class RequestCallback>
+inline void ImplCycleCollectionTraverse(
+    nsCycleCollectionTraversalCallback& aCallback,
+    RequestCallbackManager<RequestCallback>& aField, const char* aName,
+    uint32_t aFlags) {
+  aField.Traverse(aCallback);
+}
+
+}  // namespace mozilla::dom
+
+#endif

dom/base/RequestCallbackManager.h

@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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_VideoFrameProvider_h
+#define mozilla_dom_VideoFrameProvider_h
+
+#include "mozilla/dom/VideoFrameBinding.h"
+#include "mozilla/dom/HTMLVideoElementBinding.h"
+#include "mozilla/dom/RequestCallbackManager.h"
+
+namespace mozilla::dom {
+
+using VideoFrameRequest = RequestCallbackEntry<VideoFrameRequestCallback>;
+
+using VideoFrameRequestManager =
+    RequestCallbackManager<VideoFrameRequestCallback>;
+
+// Force instantiation.
+template void ImplCycleCollectionUnlink(VideoFrameRequestManager& aField);
+template void ImplCycleCollectionTraverse(
+    nsCycleCollectionTraversalCallback& aCallback,
+    VideoFrameRequestManager& aField, const char* aName, uint32_t aFlags);
+
+}  // namespace mozilla::dom
+#endif  // mozilla_dom_VideoFrameProvider_h

dom/base/VideoFrameProvider.h

@@ -258,6 +258,7 @@ EXPORTS.mozilla.dom += [
     "PostMessageEvent.h",
     "ProcessMessageManager.h",
     "RadioGroupContainer.h",
+    "RequestCallbackManager.h",
     "ResizeObserver.h",
     "ResponsiveImageSelector.h",
     "SameProcessMessageQueue.h",
@@ -289,6 +290,7 @@ EXPORTS.mozilla.dom += [
     "UnbindContext.h",
     "UseCounterMetrics.h",
     "UserActivation.h",
+    "VideoFrameProvider.h",
     "ViewportMetaData.h",
     "VisualViewport.h",
     "WindowFeatures.h",
@@ -320,7 +322,6 @@ if CONFIG["COMPILE_ENVIRONMENT"]:
 UNIFIED_SOURCES += [
     "!UseCounterMetrics.cpp",
     "AbstractRange.cpp",
-    "AnimationFrameProvider.cpp",
     "AnonymousContent.cpp",
     "Attr.cpp",
     "AttrArray.cpp",