/* -*- 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 "GPUProcessManager.h"

#include "gfxConfig.h"

#include "gfxPlatform.h"

#include "GPUProcessHost.h"

#include "GPUProcessListener.h"

#include "mozilla/MemoryReportingProcess.h"

#include "mozilla/Preferences.h"

#include "mozilla/Sprintf.h"

#include "mozilla/StaticPtr.h"

#include "mozilla/StaticPrefs_gfx.h"

#include "mozilla/StaticPrefs_layers.h"

#include "mozilla/StaticPrefs_media.h"

#include "mozilla/RemoteDecoderManagerChild.h"

#include "mozilla/RemoteDecoderManagerParent.h"

#include "mozilla/Telemetry.h"

#include "mozilla/dom/ContentParent.h"

#include "mozilla/gfx/gfxVars.h"

#include "mozilla/gfx/GPUChild.h"

#include "mozilla/ipc/Endpoint.h"

#include "mozilla/layers/APZCTreeManagerChild.h"

#include "mozilla/layers/APZInputBridgeChild.h"

#include "mozilla/layers/CompositorBridgeChild.h"

#include "mozilla/layers/CompositorBridgeParent.h"

#include "mozilla/layers/CompositorManagerChild.h"

#include "mozilla/layers/CompositorManagerParent.h"

#include "mozilla/layers/CompositorOptions.h"

#include "mozilla/layers/ImageBridgeChild.h"

#include "mozilla/layers/ImageBridgeParent.h"

#include "mozilla/layers/InProcessCompositorSession.h"

#include "mozilla/layers/LayerTreeOwnerTracker.h"

#include "mozilla/layers/RemoteCompositorSession.h"

#include "mozilla/widget/PlatformWidgetTypes.h"

#include "nsAppRunner.h"

#ifdef MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING

#  include "mozilla/widget/CompositorWidgetChild.h"

#endif

#include "nsBaseWidget.h"

#include "nsContentUtils.h"

#include "VRManagerChild.h"

#include "VRManagerParent.h"

#include "VsyncBridgeChild.h"

#include "VsyncIOThreadHolder.h"

#include "VsyncSource.h"

#include "nsExceptionHandler.h"

#include "nsPrintfCString.h"

#if defined(MOZ_WIDGET_ANDROID)

#  include "mozilla/widget/AndroidUiThread.h"

#  include "mozilla/layers/UiCompositorControllerChild.h"

#endif  // defined(MOZ_WIDGET_ANDROID)

namespace mozilla {

namespace gfx {

using namespace mozilla::layers;

enum class FallbackType : uint32_t {

  NONE = 0,

  DECODINGDISABLED,

  DISABLED,

};

static StaticAutoPtr<GPUProcessManager> sSingleton;

GPUProcessManager* GPUProcessManager::Get() { return sSingleton; }

void GPUProcessManager::Initialize() {

  MOZ_ASSERT(XRE_IsParentProcess());

  sSingleton = new GPUProcessManager();

}

void GPUProcessManager::Shutdown() { sSingleton = nullptr; }

GPUProcessManager::GPUProcessManager()

    : mTaskFactory(this),

      mNextNamespace(0),

      mIdNamespace(0),

      mResourceId(0),

      mUnstableProcessAttempts(0),

      mTotalProcessAttempts(0),

      mDeviceResetCount(0),

      mProcess(nullptr),

      mProcessToken(0),

      mProcessStable(true),

      mGPUChild(nullptr) {

  MOZ_COUNT_CTOR(GPUProcessManager);

  mIdNamespace = AllocateNamespace();

  mDeviceResetLastTime = TimeStamp::Now();

  LayerTreeOwnerTracker::Initialize();

  CompositorBridgeParent::InitializeStatics();

}

GPUProcessManager::~GPUProcessManager() {

  MOZ_COUNT_DTOR(GPUProcessManager);

  LayerTreeOwnerTracker::Shutdown();

  // The GPU process should have already been shut down.

  MOZ_ASSERT(!mProcess && !mGPUChild);

  // We should have already removed observers.

  MOZ_ASSERT(!mObserver);

}

NS_IMPL_ISUPPORTS(GPUProcessManager::Observer, nsIObserver);

GPUProcessManager::Observer::Observer(GPUProcessManager* aManager)

    : mManager(aManager) {}

NS_IMETHODIMP

GPUProcessManager::Observer::Observe(nsISupports* aSubject, const char* aTopic,

                                     const char16_t* aData) {

  if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {

    mManager->OnXPCOMShutdown();

  } else if (!strcmp(aTopic, "nsPref:changed")) {

    mManager->OnPreferenceChange(aData);

  }

  return NS_OK;

}

void GPUProcessManager::OnXPCOMShutdown() {

  if (mObserver) {

    nsContentUtils::UnregisterShutdownObserver(mObserver);

    Preferences::RemoveObserver(mObserver, "");

    mObserver = nullptr;

  }

  CleanShutdown();

}

void GPUProcessManager::OnPreferenceChange(const char16_t* aData) {

  // A pref changed. If it is useful to do so, inform child processes.

  if (!dom::ContentParent::ShouldSyncPreference(aData)) {

    return;

  }

  // We know prefs are ASCII here.

  NS_LossyConvertUTF16toASCII strData(aData);

  mozilla::dom::Pref pref(strData, /* isLocked */ false, Nothing(), Nothing());

  Preferences::GetPreference(&pref);

  if (!!mGPUChild) {

    MOZ_ASSERT(mQueuedPrefs.IsEmpty());

    mGPUChild->SendPreferenceUpdate(pref);

  } else if (IsGPUProcessLaunching()) {

    mQueuedPrefs.AppendElement(pref);

  }

}

void GPUProcessManager::LaunchGPUProcess() {

  if (mProcess) {

    return;

  }

  // Start listening for pref changes so we can

  // forward them to the process once it is running.

  if (!mObserver) {

    mObserver = new Observer(this);

    nsContentUtils::RegisterShutdownObserver(mObserver);

    Preferences::AddStrongObserver(mObserver, "");

  }

  // Start the Vsync I/O thread so can use it as soon as the process launches.

  EnsureVsyncIOThread();

  // If the process didn't live long enough, reset the stable flag so that we

  // don't end up in a restart loop.

  auto newTime = TimeStamp::Now();

  if (mTotalProcessAttempts > 0) {

    auto delta = (int32_t)(newTime - mProcessAttemptLastTime).ToMilliseconds();

    if (delta < StaticPrefs::layers_gpu_process_stable_min_uptime_ms()) {

      mProcessStable = false;

    }

  }

  mProcessAttemptLastTime = newTime;

  if (!mProcessStable) {

    mUnstableProcessAttempts++;

  }

  mTotalProcessAttempts++;

  mProcessStable = false;

  std::vector<std::string> extraArgs;

  nsCString parentBuildID(mozilla::PlatformBuildID());

  extraArgs.push_back("-parentBuildID");

  extraArgs.push_back(parentBuildID.get());

  // The subprocess is launched asynchronously, so we wait for a callback to

  // acquire the IPDL actor.

  mProcess = new GPUProcessHost(this);

  if (!mProcess->Launch(extraArgs)) {

    DisableGPUProcess("Failed to launch GPU process");

  }

}

bool GPUProcessManager::IsGPUProcessLaunching() {

  MOZ_ASSERT(NS_IsMainThread());

  return !!mProcess && !mGPUChild;

}

void GPUProcessManager::DisableGPUProcess(const char* aMessage) {

  MaybeDisableGPUProcess(aMessage, /* aAllowRestart */ false);

}

bool GPUProcessManager::MaybeDisableGPUProcess(const char* aMessage,

                                               bool aAllowRestart) {

  if (!gfxConfig::IsEnabled(Feature::GPU_PROCESS)) {

    return true;

  }

  if (!aAllowRestart) {

    gfxConfig::SetFailed(Feature::GPU_PROCESS, FeatureStatus::Failed, aMessage);

  }

  bool wantRestart = gfxPlatform::FallbackFromAcceleration(

      FeatureStatus::Unavailable, "GPU Process is disabled",

      "FEATURE_FAILURE_GPU_PROCESS_DISABLED"_ns);

  if (aAllowRestart && wantRestart) {

    // The fallback method can make use of the GPU process.

    return false;

  }

  if (aAllowRestart) {

    gfxConfig::SetFailed(Feature::GPU_PROCESS, FeatureStatus::Failed, aMessage);

  }

  gfxCriticalNote << aMessage;

  gfxPlatform::DisableGPUProcess();

  Telemetry::Accumulate(Telemetry::GPU_PROCESS_CRASH_FALLBACKS,

                        uint32_t(FallbackType::DISABLED));

  DestroyProcess();

  ShutdownVsyncIOThread();

  // We may have been in the middle of guaranteeing our various services are

  // available when one failed. Some callers may fallback to using the same

  // process equivalent, and we need to make sure those services are setup

  // correctly. We cannot re-enter DisableGPUProcess from this call because we

  // know that it is disabled in the config above.

  EnsureProtocolsReady();

  // If we disable the GPU process during reinitialization after a previous

  // crash, then we need to tell the content processes again, because they

  // need to rebind to the UI process.

  HandleProcessLost();

  return true;

}

bool GPUProcessManager::EnsureGPUReady() {

  if (mProcess && !mProcess->IsConnected()) {

    if (!mProcess->WaitForLaunch()) {

      // If this fails, we should have fired OnProcessLaunchComplete and

      // removed the process.

      MOZ_ASSERT(!mProcess && !mGPUChild);

      return false;

    }

  }

  if (mGPUChild) {

    if (mGPUChild->EnsureGPUReady()) {

      return true;

    }

    // If the initialization above fails, we likely have a GPU process teardown

    // waiting in our message queue (or will soon). We need to ensure we don't

    // restart it later because if we fail here, our callers assume they should

    // fall back to a combined UI/GPU process. This also ensures our internal

    // state is consistent (e.g. process token is reset).

    DisableGPUProcess("Failed to initialize GPU process");

  }

  return false;

}

void GPUProcessManager::EnsureProtocolsReady() {

  EnsureCompositorManagerChild();

  EnsureImageBridgeChild();

  EnsureVRManager();

}

void GPUProcessManager::EnsureCompositorManagerChild() {

  bool gpuReady = EnsureGPUReady();

  if (CompositorManagerChild::IsInitialized(mProcessToken)) {

    return;

  }

  if (!gpuReady) {

    CompositorManagerChild::InitSameProcess(AllocateNamespace(), mProcessToken);

    return;

  }

  ipc::Endpoint<PCompositorManagerParent> parentPipe;

  ipc::Endpoint<PCompositorManagerChild> childPipe;

  nsresult rv = PCompositorManager::CreateEndpoints(

      mGPUChild->OtherPid(), base::GetCurrentProcId(), &parentPipe, &childPipe);

  if (NS_FAILED(rv)) {

    DisableGPUProcess("Failed to create PCompositorManager endpoints");

    return;

  }

  mGPUChild->SendInitCompositorManager(std::move(parentPipe));

  CompositorManagerChild::Init(std::move(childPipe), AllocateNamespace(),

                               mProcessToken);

}

void GPUProcessManager::EnsureImageBridgeChild() {

  if (ImageBridgeChild::GetSingleton()) {

    return;