gfx/vr/ipc/VRChild.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "VRChild.h"
   8 #include "VRProcessManager.h"
   9 #include "VRProcessParent.h"
  10 #include "gfxConfig.h"
  11
  12 #include "mozilla/gfx/gfxVars.h"
  13 #include "mozilla/ClearOnShutdown.h"
  14 #include "mozilla/Telemetry.h"
  15 #include "mozilla/VsyncDispatcher.h"
  16 #include "mozilla/dom/MemoryReportRequest.h"
  17
  18 namespace mozilla {
  19 namespace gfx {
  20
  21 class OpenVRControllerManifestManager {
  22   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(OpenVRControllerManifestManager)
  23  public:
  24   explicit OpenVRControllerManifestManager() = default;
  25
  26   void SetOpenVRControllerActionPath(const nsCString& aPath) {
  27     mAction = aPath;
  28   }
  29
  30   void SetOpenVRControllerManifestPath(VRControllerType aType,
  31                                        const nsCString& aPath) {
  32     mManifest.InsertOrUpdate(static_cast<uint32_t>(aType), aPath);
  33   }
  34
  35   bool GetActionPath(nsCString* aPath) {
  36     if (!mAction.IsEmpty()) {
  37       *aPath = mAction;
  38       return true;
  39     }
  40     return false;
  41   }
  42
  43   bool GetManifestPath(VRControllerType aType, nsCString* aPath) {
  44     return mManifest.Get(static_cast<uint32_t>(aType), aPath);
  45   }
  46
  47  private:
  48   ~OpenVRControllerManifestManager() {
  49     if (!mAction.IsEmpty() && remove(mAction.BeginReading()) != 0) {
  50       MOZ_ASSERT(false, "Delete controller action file failed.");
  51     }
  52     mAction = "";
  53
  54     for (const auto& path : mManifest.Values()) {
  55       if (!path.IsEmpty() && remove(path.BeginReading()) != 0) {
  56         MOZ_ASSERT(false, "Delete controller manifest file failed.");
  57       }
  58     }
  59     mManifest.Clear();
  60   }
  61
  62   nsCString mAction;
  63   nsTHashMap<nsUint32HashKey, nsCString> mManifest;
  64   OpenVRControllerManifestManager(const OpenVRControllerManifestManager&) =
  65       delete;
  66
  67   const OpenVRControllerManifestManager& operator=(
  68       const OpenVRControllerManifestManager&) = delete;
  69 };
  70
  71 StaticRefPtr<OpenVRControllerManifestManager> sOpenVRControllerManifestManager;
  72
  73 VRChild::VRChild(VRProcessParent* aHost) : mHost(aHost), mVRReady(false) {
  74   MOZ_ASSERT(XRE_IsParentProcess());
  75 }
  76
  77 VRChild::~VRChild() = default;
  78
  79 mozilla::ipc::IPCResult VRChild::RecvAddMemoryReport(
  80     const MemoryReport& aReport) {
  81   if (mMemoryReportRequest) {
  82     mMemoryReportRequest->RecvReport(aReport);
  83   }
  84   return IPC_OK();
  85 }
  86
  87 void VRChild::ActorDestroy(ActorDestroyReason aWhy) {
  88   if (aWhy == AbnormalShutdown) {
  89     GenerateCrashReport(OtherPid());
  90
  91     Telemetry::Accumulate(
  92         Telemetry::SUBPROCESS_ABNORMAL_ABORT,
  93         nsDependentCString(XRE_GeckoProcessTypeToString(GeckoProcessType_VR)),
  94         1);
  95   }
  96   gfxVars::RemoveReceiver(this);
  97   mHost->OnChannelClosed();
  98 }
  99
 100 void VRChild::Init() {
 101   nsTArray<GfxVarUpdate> updates = gfxVars::FetchNonDefaultVars();
 102
 103   DevicePrefs devicePrefs;
 104   devicePrefs.hwCompositing() = gfxConfig::GetValue(Feature::HW_COMPOSITING);
 105   devicePrefs.d3d11Compositing() =
 106       gfxConfig::GetValue(Feature::D3D11_COMPOSITING);
 107   devicePrefs.oglCompositing() =
 108       gfxConfig::GetValue(Feature::OPENGL_COMPOSITING);
 109   devicePrefs.useD2D1() = gfxConfig::GetValue(Feature::DIRECT2D);
 110
 111   SendInit(updates, devicePrefs);
 112
 113   if (!sOpenVRControllerManifestManager) {
 114     sOpenVRControllerManifestManager = new OpenVRControllerManifestManager();
 115     NS_DispatchToMainThread(NS_NewRunnableFunction(
 116         "ClearOnShutdown OpenVRControllerManifestManager",
 117         []() { ClearOnShutdown(&sOpenVRControllerManifestManager); }));
 118   }
 119
 120   nsCString output;
 121   if (sOpenVRControllerManifestManager->GetActionPath(&output)) {
 122     SendOpenVRControllerActionPathToVR(output);
 123   }
 124   if (sOpenVRControllerManifestManager->GetManifestPath(
 125           VRControllerType::HTCVive, &output)) {
 126     SendOpenVRControllerManifestPathToVR(VRControllerType::HTCVive, output);
 127   }
 128   if (sOpenVRControllerManifestManager->GetManifestPath(VRControllerType::MSMR,
 129                                                         &output)) {
 130     SendOpenVRControllerManifestPathToVR(VRControllerType::MSMR, output);
 131   }
 132   if (sOpenVRControllerManifestManager->GetManifestPath(
 133           VRControllerType::ValveIndex, &output)) {
 134     SendOpenVRControllerManifestPathToVR(VRControllerType::ValveIndex, output);
 135   }
 136   gfxVars::AddReceiver(this);
 137 }
 138
 139 bool VRChild::EnsureVRReady() {
 140   if (!mVRReady) {
 141     return false;
 142   }
 143
 144   return true;
 145 }
 146
 147 mozilla::ipc::IPCResult VRChild::RecvOpenVRControllerActionPathToParent(
 148     const nsCString& aPath) {
 149   sOpenVRControllerManifestManager->SetOpenVRControllerActionPath(aPath);
 150   return IPC_OK();
 151 }
 152
 153 mozilla::ipc::IPCResult VRChild::RecvOpenVRControllerManifestPathToParent(
 154     const VRControllerType& aType, const nsCString& aPath) {
 155   sOpenVRControllerManifestManager->SetOpenVRControllerManifestPath(aType,
 156                                                                     aPath);
 157   return IPC_OK();
 158 }
 159
 160 mozilla::ipc::IPCResult VRChild::RecvInitComplete() {
 161   // We synchronously requested VR parameters before this arrived.
 162   mVRReady = true;
 163   return IPC_OK();
 164 }
 165
 166 bool VRChild::SendRequestMemoryReport(const uint32_t& aGeneration,
 167                                       const bool& aAnonymize,
 168                                       const bool& aMinimizeMemoryUsage,
 169                                       const Maybe<FileDescriptor>& aDMDFile) {
 170   mMemoryReportRequest = MakeUnique<MemoryReportRequestHost>(aGeneration);
 171
 172   PVRChild::SendRequestMemoryReport(
 173       aGeneration, aAnonymize, aMinimizeMemoryUsage, aDMDFile,
 174       [&](const uint32_t& aGeneration2) {
 175         if (VRProcessManager* vpm = VRProcessManager::Get()) {
 176           if (VRChild* child = vpm->GetVRChild()) {
 177             if (child->mMemoryReportRequest) {
 178               child->mMemoryReportRequest->Finish(aGeneration2);
 179               child->mMemoryReportRequest = nullptr;
 180             }
 181           }
 182         }
 183       },
 184       [&](mozilla::ipc::ResponseRejectReason) {
 185         if (VRProcessManager* vpm = VRProcessManager::Get()) {
 186           if (VRChild* child = vpm->GetVRChild()) {
 187             child->mMemoryReportRequest = nullptr;
 188           }
 189         }
 190       });
 191
 192   return true;
 193 }
 194
 195 void VRChild::OnVarChanged(const GfxVarUpdate& aVar) { SendUpdateVar(aVar); }
 196
 197 class DeferredDeleteVRChild : public Runnable {
 198  public:
 199   explicit DeferredDeleteVRChild(RefPtr<VRChild>&& aChild)
 200       : Runnable("gfx::DeferredDeleteVRChild"), mChild(std::move(aChild)) {}
 201
 202   NS_IMETHODIMP Run() override { return NS_OK; }
 203
 204  private:
 205   RefPtr<VRChild> mChild;
 206 };
 207
 208 /* static */
 209 void VRChild::Destroy(RefPtr<VRChild>&& aChild) {
 210   NS_DispatchToMainThread(new DeferredDeleteVRChild(std::move(aChild)));
 211 }
 212
 213 }  // namespace gfx
 214 }  // namespace mozilla