/* -*- 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 "mozilla/layers/CompositorBridgeChild.h"

#include "mozilla/layers/CompositorBridgeParent.h"

#include "mozilla/layers/CompositorThread.h"

#include <stddef.h>     // for size_t

#include "base/task.h"  // for NewRunnableMethod, etc

#include "mozilla/StaticPrefs_layers.h"

#include "mozilla/layers/CompositorManagerChild.h"

#include "mozilla/layers/ImageBridgeChild.h"

#include "mozilla/layers/APZChild.h"

#include "mozilla/layers/IAPZCTreeManager.h"

#include "mozilla/layers/APZCTreeManagerChild.h"

#include "mozilla/layers/CanvasChild.h"

#include "mozilla/layers/PTextureChild.h"

#include "mozilla/layers/TextureClient.h"      // for TextureClient

#include "mozilla/layers/TextureClientPool.h"  // for TextureClientPool

#include "mozilla/layers/WebRenderBridgeChild.h"

#include "mozilla/layers/SyncObject.h"  // for SyncObjectClient

#include "mozilla/gfx/gfxVars.h"

#include "mozilla/gfx/GPUProcessManager.h"

#include "mozilla/gfx/Logging.h"

#include "mozilla/ipc/Endpoint.h"

#include "mozilla/webgpu/WebGPUChild.h"

#include "mozilla/mozalloc.h"  // for operator new, etc

#include "mozilla/Telemetry.h"

#include "gfxConfig.h"

#include "nsDebug.h"          // for NS_WARNING

#include "nsISupportsImpl.h"  // for MOZ_COUNT_CTOR, etc

#include "nsTArray.h"         // for nsTArray, nsTArray_Impl

#include "mozilla/dom/BrowserChild.h"

#include "mozilla/dom/BrowserParent.h"

#include "mozilla/dom/ContentChild.h"

#include "mozilla/Unused.h"

#include "mozilla/DebugOnly.h"

#include "mozilla/SpinEventLoopUntil.h"

#include "nsThreadUtils.h"

#if defined(XP_WIN)

#  include "WinUtils.h"

#endif

#include "mozilla/widget/CompositorWidget.h"

#ifdef MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING

#  include "mozilla/widget/CompositorWidgetChild.h"

#endif

#include "VsyncSource.h"

#ifdef MOZ_WIDGET_ANDROID

#  include "mozilla/layers/AndroidHardwareBuffer.h"

#endif

using mozilla::Unused;

using mozilla::gfx::GPUProcessManager;

namespace mozilla {

namespace layers {

static int sShmemCreationCounter = 0;

static void ResetShmemCounter() { sShmemCreationCounter = 0; }

static void ShmemAllocated(CompositorBridgeChild* aProtocol) {

  sShmemCreationCounter++;

  if (sShmemCreationCounter > 256) {

    aProtocol->SendSyncWithCompositor();

    ResetShmemCounter();

    MOZ_PERFORMANCE_WARNING(

        "gfx", "The number of shmem allocations is too damn high!");

  }

}

static StaticRefPtr<CompositorBridgeChild> sCompositorBridge;

Atomic<int32_t> KnowsCompositor::sSerialCounter(0);

CompositorBridgeChild::CompositorBridgeChild(CompositorManagerChild* aManager)

    : mCompositorManager(aManager),

      mIdNamespace(0),

      mResourceId(0),

      mCanSend(false),

      mActorDestroyed(false),

      mFwdTransactionId(0),

      mThread(NS_GetCurrentThread()),

      mProcessToken(0),

      mSectionAllocator(nullptr),

      mPaintLock("CompositorBridgeChild.mPaintLock"),

      mTotalAsyncPaints(0),

      mOutstandingAsyncPaints(0),

      mOutstandingAsyncEndTransaction(false),

      mIsDelayingForAsyncPaints(false),

      mSlowFlushCount(0),

      mTotalFlushCount(0) {

  MOZ_ASSERT(NS_IsMainThread());

}

CompositorBridgeChild::~CompositorBridgeChild() {

  if (mCanSend) {

    gfxCriticalError() << "CompositorBridgeChild was not deinitialized";

  }

}

bool CompositorBridgeChild::IsSameProcess() const {

  return OtherPid() == base::GetCurrentProcId();

}

void CompositorBridgeChild::PrepareFinalDestroy() {

  // Because of medium high priority DidComposite, we need to repost to

  // medium high priority queue to ensure the actor is destroyed after possible

  // pending DidComposite message.

  nsCOMPtr<nsIRunnable> runnable =

      NewRunnableMethod("CompositorBridgeChild::AfterDestroy", this,

                        &CompositorBridgeChild::AfterDestroy);

  NS_DispatchToCurrentThreadQueue(runnable.forget(),

                                  EventQueuePriority::MediumHigh);

}

void CompositorBridgeChild::AfterDestroy() {

  // Note that we cannot rely upon mCanSend here because we already set that to

  // false to prevent normal IPDL calls from being made after SendWillClose.

  // The only time we should not issue Send__delete__ is if the actor is already

  // destroyed, e.g. the compositor process crashed.

  if (!mActorDestroyed) {

    Send__delete__(this);

    mActorDestroyed = true;

  }

  if (mCanvasChild) {

    mCanvasChild->Destroy();

  }

  if (sCompositorBridge == this) {

    sCompositorBridge = nullptr;

  }

}

void CompositorBridgeChild::Destroy() {

  // This must not be called from the destructor!

  mTexturesWaitingNotifyNotUsed.clear();

  // Destroying the layer manager may cause all sorts of things to happen, so

  // let's make sure there is still a reference to keep this alive whatever

  // happens.

  RefPtr<CompositorBridgeChild> selfRef = this;

  for (size_t i = 0; i < mTexturePools.Length(); i++) {

    mTexturePools[i]->Destroy();

  }

  if (mSectionAllocator) {

    delete mSectionAllocator;

    mSectionAllocator = nullptr;

  }

  if (mLayerManager) {

    mLayerManager->Destroy();

    mLayerManager = nullptr;

  }

  if (!mCanSend) {

    // We may have already called destroy but still have lingering references

    // or CompositorBridgeChild::ActorDestroy was called. Ensure that we do our

    // post destroy clean up no matter what. It is safe to call multiple times.

    NS_GetCurrentThread()->Dispatch(

        NewRunnableMethod("CompositorBridgeChild::PrepareFinalDestroy", selfRef,

                          &CompositorBridgeChild::PrepareFinalDestroy));

    return;

  }

  AutoTArray<PWebRenderBridgeChild*, 16> wrBridges;

  ManagedPWebRenderBridgeChild(wrBridges);

  for (int i = wrBridges.Length() - 1; i >= 0; --i) {

    RefPtr<WebRenderBridgeChild> wrBridge =

        static_cast<WebRenderBridgeChild*>(wrBridges[i]);

    wrBridge->Destroy(/* aIsSync */ false);

  }

  AutoTArray<PAPZChild*, 16> apzChildren;

  ManagedPAPZChild(apzChildren);

  for (PAPZChild* child : apzChildren) {

    Unused << child->SendDestroy();

  }

  AutoTArray<PWebGPUChild*, 16> webGPUChildren;

  ManagedPWebGPUChild(webGPUChildren);

  for (PWebGPUChild* child : webGPUChildren) {

    Unused << child->SendShutdown();

  }

  const ManagedContainer<PTextureChild>& textures = ManagedPTextureChild();

  for (const auto& key : textures) {

    RefPtr<TextureClient> texture = TextureClient::AsTextureClient(key);

    if (texture) {

      texture->Destroy();

    }

  }

  // The WillClose message is synchronous, so we know that after it returns

  // any messages sent by the above code will have been processed on the

  // other side.

  SendWillClose();

  mCanSend = false;

  // We no longer care about unexpected shutdowns, in the remote process case.

  mProcessToken = 0;

  // The call just made to SendWillClose can result in IPC from the

  // CompositorBridgeParent to the CompositorBridgeChild (e.g. caused by the

  // destruction of shared memory). We need to ensure this gets processed by the

  // CompositorBridgeChild before it gets destroyed. It suffices to ensure that

  // events already in the thread get processed before the

  // CompositorBridgeChild is destroyed, so we add a task to the thread to

  // handle compositor destruction.

  // From now on we can't send any message message.

  NS_GetCurrentThread()->Dispatch(

      NewRunnableMethod("CompositorBridgeChild::PrepareFinalDestroy", selfRef,

                        &CompositorBridgeChild::PrepareFinalDestroy));

}

// static

void CompositorBridgeChild::ShutDown() {

  if (sCompositorBridge) {

    sCompositorBridge->Destroy();

    SpinEventLoopUntil([&]() { return !sCompositorBridge; });

  }

}

void CompositorBridgeChild::InitForContent(uint32_t aNamespace) {

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(aNamespace);

  if (RefPtr<CompositorBridgeChild> old = sCompositorBridge.forget()) {

    // Note that at this point, ActorDestroy may not have been called yet,

    // meaning mCanSend is still true. In this case we will try to send a

    // synchronous WillClose message to the parent, and will certainly get

    // a false result and a MsgDropped processing error. This is okay.

    old->Destroy();

  }

  mCanSend = true;

  mIdNamespace = aNamespace;

  sCompositorBridge = this;

}

void CompositorBridgeChild::InitForWidget(uint64_t aProcessToken,

                                          uint32_t aNamespace) {

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(aProcessToken);

  MOZ_ASSERT(aLayerManager);

  MOZ_ASSERT(aNamespace);

  mCanSend = true;

  mProcessToken = aProcessToken;

  mLayerManager = aLayerManager;

  mIdNamespace = aNamespace;

}

/*static*/

CompositorBridgeChild* CompositorBridgeChild::Get() {

  // This is only expected to be used in child processes. While the parent

  // process does have CompositorBridgeChild instances, it has _multiple_ (one

  // per window), and therefore there is no global singleton available.

  MOZ_ASSERT(!XRE_IsParentProcess());

  return sCompositorBridge;

}

// static

bool CompositorBridgeChild::ChildProcessHasCompositorBridge() {

  return sCompositorBridge != nullptr;

}

/* static */

bool CompositorBridgeChild::CompositorIsInGPUProcess() {

  MOZ_ASSERT(NS_IsMainThread());

  if (XRE_IsParentProcess()) {

    return !!GPUProcessManager::Get()->GetGPUChild();

  }

  MOZ_ASSERT(XRE_IsContentProcess());

  CompositorBridgeChild* bridge = CompositorBridgeChild::Get();

  if (!bridge) {

    return false;

  }

  return bridge->OtherPid() != dom::ContentChild::GetSingleton()->OtherPid();

}

mozilla::ipc::IPCResult CompositorBridgeChild::RecvInvalidateLayers(

    const LayersId& aLayersId) {

  if (mLayerManager) {

    MOZ_ASSERT(!aLayersId.IsValid());

  } else if (aLayersId.IsValid()) {

    if (dom::BrowserChild* child = dom::BrowserChild::GetFrom(aLayersId)) {

      child->InvalidateLayers();

    }

  }

  return IPC_OK();

}

mozilla::ipc::IPCResult CompositorBridgeChild::RecvDidComposite(

    const LayersId& aId, const nsTArray<TransactionId>& aTransactionIds,

    const TimeStamp& aCompositeStart, const TimeStamp& aCompositeEnd) {

  // Hold a reference to keep texture pools alive.  See bug 1387799

  const auto texturePools = mTexturePools.Clone();

  for (const auto& id : aTransactionIds) {

    if (mLayerManager) {

      MOZ_ASSERT(!aId.IsValid());

      MOZ_ASSERT(mLayerManager->GetBackendType() ==

                     LayersBackend::LAYERS_CLIENT ||

                 mLayerManager->GetBackendType() == LayersBackend::LAYERS_WR);