hal/sandbox/SandboxHal.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set sw=2 ts=8 et ft=cpp : */
   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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "Hal.h"
   8 #include "HalLog.h"
   9 #include "mozilla/dom/ContentChild.h"
  10 #include "mozilla/hal_sandbox/PHalChild.h"
  11 #include "mozilla/hal_sandbox/PHalParent.h"
  12 #include "mozilla/dom/BrowserParent.h"
  13 #include "mozilla/dom/BrowserChild.h"
  14 #include "mozilla/EnumeratedRange.h"
  15 #include "mozilla/Observer.h"
  16 #include "mozilla/Unused.h"
  17 #include "WindowIdentifier.h"
  18
  19 using namespace mozilla;
  20 using namespace mozilla::dom;
  21 using namespace mozilla::hal;
  22
  23 namespace mozilla {
  24 namespace hal_sandbox {
  25
  26 static bool sHalChildDestroyed = false;
  27
  28 bool HalChildDestroyed() { return sHalChildDestroyed; }
  29
  30 static PHalChild* sHal;
  31 static PHalChild* Hal() {
  32   if (!sHal) {
  33     sHal = ContentChild::GetSingleton()->SendPHalConstructor();
  34   }
  35   return sHal;
  36 }
  37
  38 void Vibrate(const nsTArray<uint32_t>& pattern, WindowIdentifier&& id) {
  39   HAL_LOG("Vibrate: Sending to parent process.");
  40
  41   WindowIdentifier newID(std::move(id));
  42   newID.AppendProcessID();
  43   if (BrowserChild* bc = BrowserChild::GetFrom(newID.GetWindow())) {
  44     Hal()->SendVibrate(pattern, newID.AsArray(), WrapNotNull(bc));
  45   }
  46 }
  47
  48 void CancelVibrate(WindowIdentifier&& id) {
  49   HAL_LOG("CancelVibrate: Sending to parent process.");
  50
  51   WindowIdentifier newID(std::move(id));
  52   newID.AppendProcessID();
  53   if (BrowserChild* bc = BrowserChild::GetFrom(newID.GetWindow())) {
  54     Hal()->SendCancelVibrate(newID.AsArray(), WrapNotNull(bc));
  55   }
  56 }
  57
  58 void EnableBatteryNotifications() { Hal()->SendEnableBatteryNotifications(); }
  59
  60 void DisableBatteryNotifications() { Hal()->SendDisableBatteryNotifications(); }
  61
  62 void GetCurrentBatteryInformation(BatteryInformation* aBatteryInfo) {
  63   Hal()->SendGetCurrentBatteryInformation(aBatteryInfo);
  64 }
  65
  66 void EnableNetworkNotifications() { Hal()->SendEnableNetworkNotifications(); }
  67
  68 void DisableNetworkNotifications() { Hal()->SendDisableNetworkNotifications(); }
  69
  70 void GetCurrentNetworkInformation(NetworkInformation* aNetworkInfo) {
  71   Hal()->SendGetCurrentNetworkInformation(aNetworkInfo);
  72 }
  73
  74 RefPtr<GenericNonExclusivePromise> LockScreenOrientation(
  75     const hal::ScreenOrientation& aOrientation) {
  76   return Hal()
  77       ->SendLockScreenOrientation(aOrientation)
  78       ->Then(GetCurrentSerialEventTarget(), __func__,
  79              [](const mozilla::MozPromise<nsresult, ipc::ResponseRejectReason,
  80                                           true>::ResolveOrRejectValue& aValue) {
  81                if (aValue.IsResolve()) {
  82                  if (NS_SUCCEEDED(aValue.ResolveValue())) {
  83                    return GenericNonExclusivePromise::CreateAndResolve(
  84                        true, __func__);
  85                  }
  86                  return GenericNonExclusivePromise::CreateAndReject(
  87                      aValue.ResolveValue(), __func__);
  88                }
  89                return GenericNonExclusivePromise::CreateAndReject(
  90                    NS_ERROR_FAILURE, __func__);
  91              });
  92 }
  93
  94 void UnlockScreenOrientation() { Hal()->SendUnlockScreenOrientation(); }
  95
  96 void EnableSensorNotifications(SensorType aSensor) {
  97   Hal()->SendEnableSensorNotifications(aSensor);
  98 }
  99
 100 void DisableSensorNotifications(SensorType aSensor) {
 101   Hal()->SendDisableSensorNotifications(aSensor);
 102 }
 103
 104 void EnableWakeLockNotifications() { Hal()->SendEnableWakeLockNotifications(); }
 105
 106 void DisableWakeLockNotifications() {
 107   Hal()->SendDisableWakeLockNotifications();
 108 }
 109
 110 void ModifyWakeLock(const nsAString& aTopic, WakeLockControl aLockAdjust,
 111                     WakeLockControl aHiddenAdjust, uint64_t aProcessID) {
 112   MOZ_ASSERT(aProcessID != CONTENT_PROCESS_ID_UNKNOWN);
 113   Hal()->SendModifyWakeLock(aTopic, aLockAdjust, aHiddenAdjust, aProcessID);
 114 }
 115
 116 void GetWakeLockInfo(const nsAString& aTopic,
 117                      WakeLockInformation* aWakeLockInfo) {
 118   Hal()->SendGetWakeLockInfo(aTopic, aWakeLockInfo);
 119 }
 120
 121 bool EnableAlarm() {
 122   MOZ_CRASH("Alarms can't be programmed from sandboxed contexts.  Yet.");
 123 }
 124
 125 void DisableAlarm() {
 126   MOZ_CRASH("Alarms can't be programmed from sandboxed contexts.  Yet.");
 127 }
 128
 129 bool SetAlarm(int32_t aSeconds, int32_t aNanoseconds) {
 130   MOZ_CRASH("Alarms can't be programmed from sandboxed contexts.  Yet.");
 131 }
 132
 133 void SetProcessPriority(int aPid, ProcessPriority aPriority) {
 134   MOZ_CRASH("Only the main process may set processes' priorities.");
 135 }
 136
 137 class HalParent : public PHalParent,
 138                   public BatteryObserver,
 139                   public NetworkObserver,
 140                   public ISensorObserver,
 141                   public WakeLockObserver {
 142  public:
 143   virtual void ActorDestroy(ActorDestroyReason aWhy) override {
 144     // NB: you *must* unconditionally unregister your observer here,
 145     // if it *may* be registered below.
 146     hal::UnregisterBatteryObserver(this);
 147     hal::UnregisterNetworkObserver(this);
 148     for (auto sensor : MakeEnumeratedRange(NUM_SENSOR_TYPE)) {
 149       hal::UnregisterSensorObserver(sensor, this);
 150     }
 151     hal::UnregisterWakeLockObserver(this);
 152   }
 153
 154   virtual mozilla::ipc::IPCResult RecvVibrate(
 155       nsTArray<unsigned int>&& pattern, nsTArray<uint64_t>&& id,
 156       NotNull<PBrowserParent*> browserParent) override {
 157     // We give all content vibration permission.
 158     //    BrowserParent *browserParent = BrowserParent::GetFrom(browserParent);
 159     /* xxxkhuey wtf
 160     nsCOMPtr<nsIDOMWindow> window =
 161       do_QueryInterface(browserParent->GetBrowserDOMWindow());
 162     */
 163     hal::Vibrate(pattern, WindowIdentifier(std::move(id), nullptr));
 164     return IPC_OK();
 165   }
 166
 167   virtual mozilla::ipc::IPCResult RecvCancelVibrate(
 168       nsTArray<uint64_t>&& id,
 169       NotNull<PBrowserParent*> browserParent) override {
 170     // BrowserParent *browserParent = BrowserParent::GetFrom(browserParent);
 171     /* XXXkhuey wtf
 172     nsCOMPtr<nsIDOMWindow> window =
 173       browserParent->GetBrowserDOMWindow();
 174     */
 175     hal::CancelVibrate(WindowIdentifier(std::move(id), nullptr));
 176     return IPC_OK();
 177   }
 178
 179   virtual mozilla::ipc::IPCResult RecvEnableBatteryNotifications() override {
 180     // We give all content battery-status permission.
 181     hal::RegisterBatteryObserver(this);
 182     return IPC_OK();
 183   }
 184
 185   virtual mozilla::ipc::IPCResult RecvDisableBatteryNotifications() override {
 186     hal::UnregisterBatteryObserver(this);
 187     return IPC_OK();
 188   }
 189
 190   virtual mozilla::ipc::IPCResult RecvGetCurrentBatteryInformation(
 191       BatteryInformation* aBatteryInfo) override {
 192     // We give all content battery-status permission.
 193     hal::GetCurrentBatteryInformation(aBatteryInfo);
 194     return IPC_OK();
 195   }
 196
 197   void Notify(const BatteryInformation& aBatteryInfo) override {
 198     Unused << SendNotifyBatteryChange(aBatteryInfo);
 199   }
 200
 201   virtual mozilla::ipc::IPCResult RecvEnableNetworkNotifications() override {
 202     // We give all content access to this network-status information.
 203     hal::RegisterNetworkObserver(this);
 204     return IPC_OK();
 205   }
 206
 207   virtual mozilla::ipc::IPCResult RecvDisableNetworkNotifications() override {
 208     hal::UnregisterNetworkObserver(this);
 209     return IPC_OK();
 210   }
 211
 212   virtual mozilla::ipc::IPCResult RecvGetCurrentNetworkInformation(
 213       NetworkInformation* aNetworkInfo) override {
 214     hal::GetCurrentNetworkInformation(aNetworkInfo);
 215     return IPC_OK();
 216   }
 217
 218   void Notify(const NetworkInformation& aNetworkInfo) override {
 219     Unused << SendNotifyNetworkChange(aNetworkInfo);
 220   }
 221
 222   virtual mozilla::ipc::IPCResult RecvLockScreenOrientation(
 223       const ScreenOrientation& aOrientation,
 224       LockScreenOrientationResolver&& aResolve) override {
 225     // FIXME/bug 777980: unprivileged content may only lock
 226     // orientation while fullscreen.  We should check whether the
 227     // request comes from an actor in a process that might be
 228     // fullscreen.  We don't have that information currently.
 229
 230     hal::LockScreenOrientation(aOrientation)
 231         ->Then(
 232             GetMainThreadSerialEventTarget(), __func__,
 233             [aResolve](const GenericNonExclusivePromise::ResolveOrRejectValue&
 234                            aValue) {
 235               if (aValue.IsResolve()) {
 236                 MOZ_ASSERT(aValue.ResolveValue());
 237                 aResolve(NS_OK);
 238                 return;
 239               }
 240               aResolve(aValue.RejectValue());
 241             });
 242     return IPC_OK();
 243   }
 244
 245   virtual mozilla::ipc::IPCResult RecvUnlockScreenOrientation() override {
 246     hal::UnlockScreenOrientation();
 247     return IPC_OK();
 248   }
 249
 250   virtual mozilla::ipc::IPCResult RecvEnableSensorNotifications(
 251       const SensorType& aSensor) override {
 252     // We currently allow any content to register device-sensor
 253     // listeners.
 254     hal::RegisterSensorObserver(aSensor, this);
 255     return IPC_OK();
 256   }
 257
 258   virtual mozilla::ipc::IPCResult RecvDisableSensorNotifications(
 259       const SensorType& aSensor) override {
 260     hal::UnregisterSensorObserver(aSensor, this);
 261     return IPC_OK();
 262   }
 263
 264   void Notify(const SensorData& aSensorData) override {
 265     Unused << SendNotifySensorChange(aSensorData);
 266   }
 267
 268   virtual mozilla::ipc::IPCResult RecvModifyWakeLock(
 269       const nsAString& aTopic, const WakeLockControl& aLockAdjust,
 270       const WakeLockControl& aHiddenAdjust,
 271       const uint64_t& aProcessID) override {
 272     MOZ_ASSERT(aProcessID != CONTENT_PROCESS_ID_UNKNOWN);
 273
 274     // We allow arbitrary content to use wake locks.
 275     hal::ModifyWakeLock(aTopic, aLockAdjust, aHiddenAdjust, aProcessID);
 276     return IPC_OK();
 277   }
 278
 279   virtual mozilla::ipc::IPCResult RecvEnableWakeLockNotifications() override {
 280     // We allow arbitrary content to use wake locks.
 281     hal::RegisterWakeLockObserver(this);
 282     return IPC_OK();
 283   }
 284
 285   virtual mozilla::ipc::IPCResult RecvDisableWakeLockNotifications() override {
 286     hal::UnregisterWakeLockObserver(this);
 287     return IPC_OK();
 288   }
 289
 290   virtual mozilla::ipc::IPCResult RecvGetWakeLockInfo(
 291       const nsAString& aTopic, WakeLockInformation* aWakeLockInfo) override {
 292     hal::GetWakeLockInfo(aTopic, aWakeLockInfo);
 293     return IPC_OK();
 294   }
 295
 296   void Notify(const WakeLockInformation& aWakeLockInfo) override {
 297     Unused << SendNotifyWakeLockChange(aWakeLockInfo);
 298   }
 299 };
 300
 301 class HalChild : public PHalChild {
 302  public:
 303   virtual void ActorDestroy(ActorDestroyReason aWhy) override {
 304     sHalChildDestroyed = true;
 305   }
 306
 307   virtual mozilla::ipc::IPCResult RecvNotifyBatteryChange(
 308       const BatteryInformation& aBatteryInfo) override {
 309     hal::NotifyBatteryChange(aBatteryInfo);
 310     return IPC_OK();
 311   }
 312
 313   virtual mozilla::ipc::IPCResult RecvNotifySensorChange(
 314       const hal::SensorData& aSensorData) override;
 315
 316   virtual mozilla::ipc::IPCResult RecvNotifyNetworkChange(
 317       const NetworkInformation& aNetworkInfo) override {
 318     hal::NotifyNetworkChange(aNetworkInfo);
 319     return IPC_OK();
 320   }
 321
 322   virtual mozilla::ipc::IPCResult RecvNotifyWakeLockChange(
 323       const WakeLockInformation& aWakeLockInfo) override {
 324     hal::NotifyWakeLockChange(aWakeLockInfo);
 325     return IPC_OK();
 326   }
 327 };
 328
 329 mozilla::ipc::IPCResult HalChild::RecvNotifySensorChange(
 330     const hal::SensorData& aSensorData) {
 331   hal::NotifySensorChange(aSensorData);
 332
 333   return IPC_OK();
 334 }
 335
 336 PHalChild* CreateHalChild() { return new HalChild(); }
 337
 338 PHalParent* CreateHalParent() { return new HalParent(); }
 339
 340 }  // namespace hal_sandbox
 341 }  // namespace mozilla