Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 236 insertions, 0 deletions

diff --git a/gfx/ipc/CanvasManagerParent.cpp b/gfx/ipc/CanvasManagerParent.cpp
new file mode 100644
index 0000000000..50fdb6e104
--- /dev/null
+++ b/gfx/ipc/CanvasManagerParent.cpp
@@ -0,0 +1,236 @@
+/* -*- 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/. */
+
+#include "CanvasManagerParent.h"
+#include "gfxPlatform.h"
+#include "mozilla/dom/WebGLParent.h"
+#include "mozilla/gfx/CanvasRenderThread.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/GPUParent.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/layers/CanvasTranslator.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/ISurfaceAllocator.h"
+#include "mozilla/layers/SharedSurfacesParent.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/StaticPrefs_webgl.h"
+#include "mozilla/webgpu/WebGPUParent.h"
+#include "nsIThread.h"
+#include "nsThreadUtils.h"
+
+namespace mozilla::gfx {
+
+CanvasManagerParent::ManagerSet CanvasManagerParent::sManagers;
+
+/* static */ void CanvasManagerParent::Init(
+    Endpoint<PCanvasManagerParent>&& aEndpoint,
+    layers::SharedSurfacesHolder* aSharedSurfacesHolder,
+    const dom::ContentParentId& aContentId) {
+  MOZ_ASSERT(layers::CompositorThreadHolder::IsInCompositorThread());
+
+  auto manager =
+      MakeRefPtr<CanvasManagerParent>(aSharedSurfacesHolder, aContentId);
+
+  nsCOMPtr<nsIThread> owningThread =
+      gfx::CanvasRenderThread::GetCanvasRenderThread();
+  MOZ_ASSERT(owningThread);
+
+  owningThread->Dispatch(NewRunnableMethod<Endpoint<PCanvasManagerParent>&&>(
+      "CanvasManagerParent::Bind", manager, &CanvasManagerParent::Bind,
+      std::move(aEndpoint)));
+}
+
+/* static */ void CanvasManagerParent::Shutdown() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIThread> owningThread =
+      gfx::CanvasRenderThread::GetCanvasRenderThread();
+  MOZ_ASSERT(owningThread);
+
+  NS_DispatchAndSpinEventLoopUntilComplete(
+      "CanvasManagerParent::Shutdown"_ns, owningThread,
+      NS_NewRunnableFunction("CanvasManagerParent::Shutdown", []() -> void {
+        CanvasManagerParent::ShutdownInternal();
+      }));
+}
+
+/* static */ void CanvasManagerParent::ShutdownInternal() {
+  nsTArray<RefPtr<CanvasManagerParent>> actors(sManagers.Count());
+  // Do a copy since Close will remove the entry from the set.
+  for (const auto& actor : sManagers) {
+    actors.AppendElement(actor);
+  }
+
+  for (auto const& actor : actors) {
+    actor->Close();
+  }
+}
+
+/* static */ void CanvasManagerParent::DisableRemoteCanvas() {
+  NS_DispatchToMainThread(
+      NS_NewRunnableFunction("CanvasManagerParent::DisableRemoteCanvas", [] {
+        if (XRE_IsGPUProcess()) {
+          GPUParent::GetSingleton()->NotifyDisableRemoteCanvas();
+        } else {
+          gfxPlatform::DisableRemoteCanvas();
+        }
+      }));
+
+  if (CanvasRenderThread::IsInCanvasRenderThread()) {
+    DisableRemoteCanvasInternal();
+    return;
+  }
+
+  CanvasRenderThread::Dispatch(NS_NewRunnableFunction(
+      "CanvasManagerParent::DisableRemoteCanvas",
+      [] { CanvasManagerParent::DisableRemoteCanvasInternal(); }));
+}
+
+/* static */ void CanvasManagerParent::DisableRemoteCanvasInternal() {
+  MOZ_ASSERT(CanvasRenderThread::IsInCanvasRenderThread());
+
+  AutoTArray<RefPtr<layers::CanvasTranslator>, 16> actors;
+  for (const auto& manager : sManagers) {
+    for (const auto& canvas : manager->ManagedPCanvasParent()) {
+      actors.AppendElement(static_cast<layers::CanvasTranslator*>(canvas));
+    }
+  }
+
+  for (const auto& actor : actors) {
+    Unused << NS_WARN_IF(!actor->SendDeactivate());
+  }
+}
+
+CanvasManagerParent::CanvasManagerParent(
+    layers::SharedSurfacesHolder* aSharedSurfacesHolder,
+    const dom::ContentParentId& aContentId)
+    : mSharedSurfacesHolder(aSharedSurfacesHolder), mContentId(aContentId) {}
+
+CanvasManagerParent::~CanvasManagerParent() = default;
+
+void CanvasManagerParent::Bind(Endpoint<PCanvasManagerParent>&& aEndpoint) {
+  if (!aEndpoint.Bind(this)) {
+    NS_WARNING("Failed to bind CanvasManagerParent!");
+    return;
+  }
+
+#ifdef DEBUG
+  for (CanvasManagerParent* i : sManagers) {
+    MOZ_ASSERT_IF(i->mContentId == mContentId,
+                  i->OtherPidMaybeInvalid() == OtherPidMaybeInvalid());
+  }
+#endif
+
+  sManagers.Insert(this);
+}
+
+void CanvasManagerParent::ActorDestroy(ActorDestroyReason aWhy) {
+  sManagers.Remove(this);
+}
+
+already_AddRefed<dom::PWebGLParent> CanvasManagerParent::AllocPWebGLParent() {
+  if (NS_WARN_IF(!gfxVars::AllowWebglOop() &&
+                 !StaticPrefs::webgl_out_of_process_force())) {
+    MOZ_ASSERT_UNREACHABLE("AllocPWebGLParent without remote WebGL");
+    return nullptr;
+  }
+  return MakeAndAddRef<dom::WebGLParent>(mContentId);
+}
+
+already_AddRefed<webgpu::PWebGPUParent>
+CanvasManagerParent::AllocPWebGPUParent() {
+  if (NS_WARN_IF(!gfxVars::AllowWebGPU())) {
+    MOZ_ASSERT_UNREACHABLE("AllocPWebGPUParent without WebGPU");
+    return nullptr;
+  }
+
+  return MakeAndAddRef<webgpu::WebGPUParent>();
+}
+
+mozilla::ipc::IPCResult CanvasManagerParent::RecvInitialize(
+    const uint32_t& aId) {
+  if (!aId) {
+    return IPC_FAIL(this, "invalid id");
+  }
+  if (mId) {
+    return IPC_FAIL(this, "already initialized");
+  }
+  mId = aId;
+  return IPC_OK();
+}
+
+already_AddRefed<layers::PCanvasParent>
+CanvasManagerParent::AllocPCanvasParent() {
+  if (NS_WARN_IF(!gfx::gfxVars::RemoteCanvasEnabled() &&
+                 !gfx::gfxVars::UseAcceleratedCanvas2D())) {
+    MOZ_ASSERT_UNREACHABLE("AllocPCanvasParent without remote canvas");
+    return nullptr;
+  }
+  if (NS_WARN_IF(!mId)) {
+    MOZ_ASSERT_UNREACHABLE("AllocPCanvasParent without ID");
+    return nullptr;
+  }
+  return MakeAndAddRef<layers::CanvasTranslator>(mSharedSurfacesHolder,
+                                                 mContentId, mId);
+}
+
+mozilla::ipc::IPCResult CanvasManagerParent::RecvGetSnapshot(
+    const uint32_t& aManagerId, const int32_t& aProtocolId,
+    const Maybe<RemoteTextureOwnerId>& aOwnerId,
+    webgl::FrontBufferSnapshotIpc* aResult) {
+  if (!aManagerId) {
+    return IPC_FAIL(this, "invalid id");
+  }
+
+  IProtocol* actor = nullptr;
+  for (CanvasManagerParent* i : sManagers) {
+    if (i->mContentId == mContentId && i->mId == aManagerId) {
+      actor = i->Lookup(aProtocolId);
+      break;
+    }
+  }
+
+  if (!actor) {
+    return IPC_FAIL(this, "invalid actor");
+  }
+
+  if (actor->GetSide() != mozilla::ipc::Side::ParentSide) {
+    return IPC_FAIL(this, "unsupported actor");
+  }
+
+  webgl::FrontBufferSnapshotIpc buffer;
+  switch (actor->GetProtocolId()) {
+    case ProtocolId::PWebGLMsgStart: {
+      RefPtr<dom::WebGLParent> webgl = static_cast<dom::WebGLParent*>(actor);
+      mozilla::ipc::IPCResult rv = webgl->GetFrontBufferSnapshot(&buffer, this);
+      if (!rv) {
+        return rv;
+      }
+    } break;
+    case ProtocolId::PWebGPUMsgStart: {
+      RefPtr<webgpu::WebGPUParent> webgpu =
+          static_cast<webgpu::WebGPUParent*>(actor);
+      IntSize size;
+      if (aOwnerId.isNothing()) {
+        return IPC_FAIL(this, "invalid OwnerId");
+      }
+      mozilla::ipc::IPCResult rv =
+          webgpu->GetFrontBufferSnapshot(this, *aOwnerId, buffer.shmem, size);
+      if (!rv) {
+        return rv;
+      }
+      buffer.surfSize.x = static_cast<uint32_t>(size.width);
+      buffer.surfSize.y = static_cast<uint32_t>(size.height);
+    } break;
+    default:
+      return IPC_FAIL(this, "unsupported protocol");
+  }
+
+  *aResult = std::move(buffer);
+  return IPC_OK();
+}
+
+}  // namespace mozilla::gfx