summaryrefslogtreecommitdiffstats
path: root/gfx/ipc/CanvasManagerChild.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /gfx/ipc/CanvasManagerChild.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/ipc/CanvasManagerChild.cpp')
-rw-r--r--gfx/ipc/CanvasManagerChild.cpp338
1 files changed, 338 insertions, 0 deletions
diff --git a/gfx/ipc/CanvasManagerChild.cpp b/gfx/ipc/CanvasManagerChild.cpp
new file mode 100644
index 0000000000..eca803bc4b
--- /dev/null
+++ b/gfx/ipc/CanvasManagerChild.cpp
@@ -0,0 +1,338 @@
+/* -*- 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 "CanvasManagerChild.h"
+#include "mozilla/AppShutdown.h"
+#include "mozilla/dom/CanvasRenderingContext2D.h"
+#include "mozilla/dom/WorkerPrivate.h"
+#include "mozilla/dom/WorkerRef.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Swizzle.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/layers/ActiveResource.h"
+#include "mozilla/layers/CanvasChild.h"
+#include "mozilla/layers/CompositorManagerChild.h"
+#include "mozilla/webgpu/WebGPUChild.h"
+
+using namespace mozilla::dom;
+using namespace mozilla::layers;
+
+namespace mozilla::gfx {
+
+// The IPDL actor holds a strong reference to CanvasManagerChild which we use
+// to keep it alive. The owning thread will tell us to close when it is
+// shutdown, either via CanvasManagerChild::Shutdown for the main thread, or
+// via a shutdown callback from ThreadSafeWorkerRef for worker threads.
+MOZ_THREAD_LOCAL(CanvasManagerChild*) CanvasManagerChild::sLocalManager;
+
+Atomic<uint32_t> CanvasManagerChild::sNextId(1);
+
+CanvasManagerChild::CanvasManagerChild(uint32_t aId) : mId(aId) {}
+CanvasManagerChild::~CanvasManagerChild() = default;
+
+void CanvasManagerChild::ActorDestroy(ActorDestroyReason aReason) {
+ DestroyInternal();
+ if (sLocalManager.get() == this) {
+ sLocalManager.set(nullptr);
+ }
+ mWorkerRef = nullptr;
+}
+
+void CanvasManagerChild::DestroyInternal() {
+ std::set<CanvasRenderingContext2D*> activeCanvas = std::move(mActiveCanvas);
+ for (const auto& i : activeCanvas) {
+ i->OnShutdown();
+ }
+
+ if (mActiveResourceTracker) {
+ mActiveResourceTracker->AgeAllGenerations();
+ mActiveResourceTracker.reset();
+ }
+
+ if (mCanvasChild) {
+ mCanvasChild->Destroy();
+ mCanvasChild = nullptr;
+ }
+}
+
+void CanvasManagerChild::Destroy() {
+ DestroyInternal();
+
+ // The caller has a strong reference. ActorDestroy will clear sLocalManager
+ // and mWorkerRef.
+ Close();
+}
+
+/* static */ void CanvasManagerChild::Shutdown() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // The worker threads should destroy their own CanvasManagerChild instances
+ // during their shutdown sequence. We just need to take care of the main
+ // thread. We need to init here because we may have never created a
+ // CanvasManagerChild for the main thread in the first place.
+ if (sLocalManager.init()) {
+ RefPtr<CanvasManagerChild> manager = sLocalManager.get();
+ if (manager) {
+ manager->Destroy();
+ }
+ }
+}
+
+/* static */ bool CanvasManagerChild::CreateParent(
+ ipc::Endpoint<PCanvasManagerParent>&& aEndpoint) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ CompositorManagerChild* manager = CompositorManagerChild::GetInstance();
+ if (!manager || !manager->CanSend()) {
+ return false;
+ }
+
+ return manager->SendInitCanvasManager(std::move(aEndpoint));
+}
+
+/* static */ CanvasManagerChild* CanvasManagerChild::Get() {
+ if (NS_WARN_IF(!sLocalManager.init())) {
+ return nullptr;
+ }
+
+ CanvasManagerChild* managerWeak = sLocalManager.get();
+ if (managerWeak) {
+ return managerWeak;
+ }
+
+ // We are only used on the main thread, or on worker threads.
+ WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
+ MOZ_ASSERT_IF(!worker, NS_IsMainThread());
+
+ ipc::Endpoint<PCanvasManagerParent> parentEndpoint;
+ ipc::Endpoint<PCanvasManagerChild> childEndpoint;
+
+ auto compositorPid = CompositorManagerChild::GetOtherPid();
+ if (NS_WARN_IF(!compositorPid)) {
+ return nullptr;
+ }
+
+ nsresult rv = PCanvasManager::CreateEndpoints(
+ compositorPid, base::GetCurrentProcId(), &parentEndpoint, &childEndpoint);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return nullptr;
+ }
+
+ auto manager = MakeRefPtr<CanvasManagerChild>(sNextId++);
+
+ if (worker) {
+ // The ThreadSafeWorkerRef will let us know when the worker is shutting
+ // down. This will let us clear our threadlocal reference and close the
+ // actor. We rely upon an explicit shutdown for the main thread.
+ RefPtr<StrongWorkerRef> workerRef = StrongWorkerRef::Create(
+ worker, "CanvasManager", [manager]() { manager->Destroy(); });
+ if (NS_WARN_IF(!workerRef)) {
+ return nullptr;
+ }
+
+ manager->mWorkerRef = new ThreadSafeWorkerRef(workerRef);
+ } else if (NS_IsMainThread()) {
+ if (NS_WARN_IF(
+ AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed))) {
+ return nullptr;
+ }
+ } else {
+ MOZ_ASSERT_UNREACHABLE("Can only be used on main or DOM worker threads!");
+ return nullptr;
+ }
+
+ if (NS_WARN_IF(!childEndpoint.Bind(manager))) {
+ return nullptr;
+ }
+
+ // We can't talk to the compositor process directly from worker threads, but
+ // the main thread can via CompositorManagerChild.
+ if (worker) {
+ worker->DispatchToMainThread(NS_NewRunnableFunction(
+ "CanvasManagerChild::CreateParent",
+ [parentEndpoint = std::move(parentEndpoint)]() {
+ CreateParent(
+ std::move(const_cast<ipc::Endpoint<PCanvasManagerParent>&&>(
+ parentEndpoint)));
+ }));
+ } else if (NS_WARN_IF(!CreateParent(std::move(parentEndpoint)))) {
+ return nullptr;
+ }
+
+ manager->SendInitialize(manager->Id());
+ sLocalManager.set(manager);
+ return manager;
+}
+
+/* static */ CanvasManagerChild* CanvasManagerChild::MaybeGet() {
+ if (!sLocalManager.initialized()) {
+ return nullptr;
+ }
+
+ return sLocalManager.get();
+}
+
+void CanvasManagerChild::AddShutdownObserver(
+ dom::CanvasRenderingContext2D* aCanvas) {
+ mActiveCanvas.insert(aCanvas);
+}
+
+void CanvasManagerChild::RemoveShutdownObserver(
+ dom::CanvasRenderingContext2D* aCanvas) {
+ mActiveCanvas.erase(aCanvas);
+}
+
+void CanvasManagerChild::EndCanvasTransaction() {
+ if (!mCanvasChild) {
+ return;
+ }
+
+ mCanvasChild->EndTransaction();
+ if (mCanvasChild->ShouldBeCleanedUp()) {
+ mCanvasChild->Destroy();
+ mCanvasChild = nullptr;
+ }
+}
+
+void CanvasManagerChild::ClearCachedResources() {
+ if (mCanvasChild) {
+ mCanvasChild->ClearCachedResources();
+ }
+}
+
+void CanvasManagerChild::DeactivateCanvas() {
+ mActive = false;
+ if (mCanvasChild) {
+ mCanvasChild->Destroy();
+ mCanvasChild = nullptr;
+ }
+}
+
+void CanvasManagerChild::BlockCanvas() { mBlocked = true; }
+
+RefPtr<layers::CanvasChild> CanvasManagerChild::GetCanvasChild() {
+ if (mBlocked) {
+ return nullptr;
+ }
+
+ if (!mActive) {
+ MOZ_ASSERT(!mCanvasChild);
+ return nullptr;
+ }
+
+ if (!mCanvasChild) {
+ mCanvasChild = MakeAndAddRef<layers::CanvasChild>();
+ if (!SendPCanvasConstructor(mCanvasChild)) {
+ mCanvasChild = nullptr;
+ }
+ }
+
+ return mCanvasChild;
+}
+
+RefPtr<webgpu::WebGPUChild> CanvasManagerChild::GetWebGPUChild() {
+ if (!mWebGPUChild) {
+ mWebGPUChild = MakeAndAddRef<webgpu::WebGPUChild>();
+ if (!SendPWebGPUConstructor(mWebGPUChild)) {
+ mWebGPUChild = nullptr;
+ }
+ }
+
+ return mWebGPUChild;
+}
+
+layers::ActiveResourceTracker* CanvasManagerChild::GetActiveResourceTracker() {
+ if (!mActiveResourceTracker) {
+ mActiveResourceTracker = MakeUnique<ActiveResourceTracker>(
+ 1000, "CanvasManagerChild", GetCurrentSerialEventTarget());
+ }
+ return mActiveResourceTracker.get();
+}
+
+already_AddRefed<DataSourceSurface> CanvasManagerChild::GetSnapshot(
+ uint32_t aManagerId, int32_t aProtocolId,
+ const Maybe<RemoteTextureOwnerId>& aOwnerId, SurfaceFormat aFormat,
+ bool aPremultiply, bool aYFlip) {
+ if (!CanSend()) {
+ return nullptr;
+ }
+
+ webgl::FrontBufferSnapshotIpc res;
+ if (!SendGetSnapshot(aManagerId, aProtocolId, aOwnerId, &res)) {
+ return nullptr;
+ }
+
+ if (!res.shmem || !res.shmem->IsReadable()) {
+ return nullptr;
+ }
+
+ auto guard = MakeScopeExit([&] { DeallocShmem(res.shmem.ref()); });
+
+ if (!res.surfSize.x || !res.surfSize.y || res.surfSize.x > INT32_MAX ||
+ res.surfSize.y > INT32_MAX) {
+ return nullptr;
+ }
+
+ IntSize size(res.surfSize.x, res.surfSize.y);
+ CheckedInt32 stride = CheckedInt32(size.width) * sizeof(uint32_t);
+ if (!stride.isValid()) {
+ return nullptr;
+ }
+
+ CheckedInt32 length = stride * size.height;
+ if (!length.isValid() ||
+ size_t(length.value()) != res.shmem->Size<uint8_t>()) {
+ return nullptr;
+ }
+
+ SurfaceFormat format =
+ IsOpaque(aFormat) ? SurfaceFormat::B8G8R8X8 : SurfaceFormat::B8G8R8A8;
+ RefPtr<DataSourceSurface> surface =
+ Factory::CreateDataSourceSurfaceWithStride(size, format, stride.value(),
+ /* aZero */ false);
+ if (!surface) {
+ return nullptr;
+ }
+
+ gfx::DataSourceSurface::ScopedMap map(surface,
+ gfx::DataSourceSurface::READ_WRITE);
+ if (!map.IsMapped()) {
+ return nullptr;
+ }
+
+ // The buffer we may readback from the canvas could be R8G8B8A8, not
+ // premultiplied, and/or has its rows iverted. For the general case, we want
+ // surfaces represented as premultiplied B8G8R8A8, with its rows ordered top
+ // to bottom. Given this path is used for screenshots/SurfaceFromElement,
+ // that's the representation we need.
+ if (aYFlip) {
+ if (aPremultiply) {
+ if (!PremultiplyYFlipData(res.shmem->get<uint8_t>(), stride.value(),
+ aFormat, map.GetData(), map.GetStride(), format,
+ size)) {
+ return nullptr;
+ }
+ } else {
+ if (!SwizzleYFlipData(res.shmem->get<uint8_t>(), stride.value(), aFormat,
+ map.GetData(), map.GetStride(), format, size)) {
+ return nullptr;
+ }
+ }
+ } else if (aPremultiply) {
+ if (!PremultiplyData(res.shmem->get<uint8_t>(), stride.value(), aFormat,
+ map.GetData(), map.GetStride(), format, size)) {
+ return nullptr;
+ }
+ } else {
+ if (!SwizzleData(res.shmem->get<uint8_t>(), stride.value(), aFormat,
+ map.GetData(), map.GetStride(), format, size)) {
+ return nullptr;
+ }
+ }
+ return surface.forget();
+}
+
+} // namespace mozilla::gfx