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