import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

hal/sandbox/PHal.ipdl

@@ -0,0 +1,159 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* 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 protocol PContent;
+include protocol PBrowser;
+
+include "mozilla/GfxMessageUtils.h";
+
+using mozilla::dom::ScreenOrientationInternal from "mozilla/dom/ScreenOrientation.h";
+using mozilla::hal::SensorType from "mozilla/HalSensor.h";
+using mozilla::hal::SensorAccuracyType from "mozilla/HalSensor.h";
+using mozilla::hal::WakeLockControl from "mozilla/HalTypes.h";
+using mozilla::hal::SwitchState from "mozilla/HalTypes.h";
+using mozilla::hal::SwitchDevice from "mozilla/HalTypes.h";
+using mozilla::hal::ProcessPriority from "mozilla/HalTypes.h";
+using nsIntRect from "nsRect.h";
+using PRTime from "prtime.h";
+
+namespace mozilla {
+
+namespace hal {
+struct BatteryInformation {
+  double level;
+  bool   charging;
+  double remainingTime;
+};
+
+struct SensorData {
+  SensorType sensor;
+  PRTime timestamp;
+  float[] values;
+  SensorAccuracyType accuracy;
+};
+
+struct NetworkInformation {
+  uint32_t type;
+  bool   isWifi;
+  uint32_t dhcpGateway;
+};
+
+struct SwitchEvent {
+  SwitchDevice device;
+  SwitchState status;
+};
+
+struct WakeLockInformation {
+  nsString topic;
+  uint32_t numLocks;
+  uint32_t numHidden;
+  uint64_t[] lockingProcesses;
+};
+
+struct ScreenConfiguration {
+  nsIntRect rect;
+  ScreenOrientationInternal orientation;
+  uint16_t angle;
+  uint32_t colorDepth;
+  uint32_t pixelDepth;
+};
+
+struct SystemTimezoneChangeInformation {
+  // These timezone offsets are relative to UTC in minutes and
+  // have already taken daylight saving time (DST) into account.
+  int32_t oldTimezoneOffsetMinutes;
+  int32_t newTimezoneOffsetMinutes;
+};
+
+} // namespace hal
+
+namespace hal_sandbox {
+
+nested(upto inside_cpow) sync protocol PHal {
+    manager PContent;
+
+child:
+    async NotifyBatteryChange(BatteryInformation aBatteryInfo);
+    async NotifyNetworkChange(NetworkInformation aNetworkInfo);
+    async NotifyWakeLockChange(WakeLockInformation aWakeLockInfo);
+    async NotifyScreenConfigurationChange(ScreenConfiguration aScreenOrientation);
+    async NotifySwitchChange(SwitchEvent aEvent);
+    async NotifySystemClockChange(int64_t aClockDeltaMS); 
+    async NotifySystemTimezoneChange(SystemTimezoneChangeInformation aSystemTimezoneChangeInfo); 
+
+parent:
+    async Vibrate(uint32_t[] pattern, uint64_t[] id, PBrowser browser);
+    async CancelVibrate(uint64_t[] id, PBrowser browser);
+
+    async EnableBatteryNotifications();
+    async DisableBatteryNotifications();
+    sync GetCurrentBatteryInformation()
+      returns (BatteryInformation aBatteryInfo);
+
+    async EnableNetworkNotifications();
+    async DisableNetworkNotifications();
+    sync GetCurrentNetworkInformation()
+      returns (NetworkInformation aNetworkInfo);
+
+    sync GetScreenEnabled() returns (bool enabled);
+    async SetScreenEnabled(bool aEnabled);
+
+    sync GetKeyLightEnabled() returns (bool enabled);
+    async SetKeyLightEnabled(bool aEnabled);
+
+    sync GetCpuSleepAllowed() returns (bool allowed);
+    async SetCpuSleepAllowed(bool aAllowed);
+
+    sync GetScreenBrightness() returns (double brightness);
+    async SetScreenBrightness(double aBrightness);
+
+    async AdjustSystemClock(int64_t aDeltaMilliseconds);
+    async SetTimezone(nsCString aTimezoneSpec);
+    sync GetTimezone()
+      returns (nsCString aTimezoneSpec);
+    sync GetTimezoneOffset()
+      returns (int32_t aTimezoneOffset);
+    async EnableSystemClockChangeNotifications();
+    async DisableSystemClockChangeNotifications();
+    async EnableSystemTimezoneChangeNotifications();
+    async DisableSystemTimezoneChangeNotifications();
+
+    async ModifyWakeLock(nsString aTopic,
+                         WakeLockControl aLockAdjust,
+                         WakeLockControl aHiddenAdjust,
+                         uint64_t aProcessID);
+    async EnableWakeLockNotifications();
+    async DisableWakeLockNotifications();
+    sync GetWakeLockInfo(nsString aTopic)
+      returns (WakeLockInformation aWakeLockInfo);
+
+    async EnableScreenConfigurationNotifications();
+    async DisableScreenConfigurationNotifications();
+    nested(inside_cpow) sync GetCurrentScreenConfiguration()
+      returns (ScreenConfiguration aScreenConfiguration);
+    sync LockScreenOrientation(ScreenOrientationInternal aOrientation)
+      returns (bool allowed);
+    async UnlockScreenOrientation();
+ 
+    async EnableSwitchNotifications(SwitchDevice aDevice);
+    async DisableSwitchNotifications(SwitchDevice aDevice);
+    sync GetCurrentSwitchState(SwitchDevice aDevice)
+      returns (SwitchState aState);
+
+    async FactoryReset(nsString aReason);
+
+child:
+    async NotifySensorChange(SensorData aSensorData);
+
+parent:
+    async EnableSensorNotifications(SensorType aSensor);
+    async DisableSensorNotifications(SensorType aSensor);
+
+    async __delete__();
+};
+
+} // namespace hal
+} // namespace mozilla

hal/sandbox/SandboxHal.cpp

@@ -0,0 +1,907 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* 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 "Hal.h"
+#include "HalLog.h"
+#include "mozilla/AppProcessChecker.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/hal_sandbox/PHalChild.h"
+#include "mozilla/hal_sandbox/PHalParent.h"
+#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/battery/Types.h"
+#include "mozilla/dom/network/Types.h"
+#include "mozilla/dom/ScreenOrientation.h"
+#include "mozilla/Observer.h"
+#include "mozilla/Unused.h"
+#include "nsAutoPtr.h"
+#include "WindowIdentifier.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::hal;
+
+namespace mozilla {
+namespace hal_sandbox {
+
+static bool sHalChildDestroyed = false;
+
+bool
+HalChildDestroyed()
+{
+  return sHalChildDestroyed;
+}
+
+static PHalChild* sHal;
+static PHalChild*
+Hal()
+{
+  if (!sHal) {
+    sHal = ContentChild::GetSingleton()->SendPHalConstructor();
+  }
+  return sHal;
+}
+
+void
+Vibrate(const nsTArray<uint32_t>& pattern, const WindowIdentifier &id)
+{
+  HAL_LOG("Vibrate: Sending to parent process.");
+
+  AutoTArray<uint32_t, 8> p(pattern);
+
+  WindowIdentifier newID(id);
+  newID.AppendProcessID();
+  Hal()->SendVibrate(p, newID.AsArray(), TabChild::GetFrom(newID.GetWindow()));
+}
+
+void
+CancelVibrate(const WindowIdentifier &id)
+{
+  HAL_LOG("CancelVibrate: Sending to parent process.");
+
+  WindowIdentifier newID(id);
+  newID.AppendProcessID();
+  Hal()->SendCancelVibrate(newID.AsArray(), TabChild::GetFrom(newID.GetWindow()));
+}
+
+void
+EnableBatteryNotifications()
+{
+  Hal()->SendEnableBatteryNotifications();
+}
+
+void
+DisableBatteryNotifications()
+{
+  Hal()->SendDisableBatteryNotifications();
+}
+
+void
+GetCurrentBatteryInformation(BatteryInformation* aBatteryInfo)
+{
+  Hal()->SendGetCurrentBatteryInformation(aBatteryInfo);
+}
+
+void
+EnableNetworkNotifications()
+{
+  Hal()->SendEnableNetworkNotifications();
+}
+
+void
+DisableNetworkNotifications()
+{
+  Hal()->SendDisableNetworkNotifications();
+}
+
+void
+GetCurrentNetworkInformation(NetworkInformation* aNetworkInfo)
+{
+  Hal()->SendGetCurrentNetworkInformation(aNetworkInfo);
+}
+
+void
+EnableScreenConfigurationNotifications()
+{
+  Hal()->SendEnableScreenConfigurationNotifications();
+}
+
+void
+DisableScreenConfigurationNotifications()
+{
+  Hal()->SendDisableScreenConfigurationNotifications();
+}
+
+void
+GetCurrentScreenConfiguration(ScreenConfiguration* aScreenConfiguration)
+{
+  Hal()->SendGetCurrentScreenConfiguration(aScreenConfiguration);
+}
+
+bool
+LockScreenOrientation(const dom::ScreenOrientationInternal& aOrientation)
+{
+  bool allowed;
+  Hal()->SendLockScreenOrientation(aOrientation, &allowed);
+  return allowed;
+}
+
+void
+UnlockScreenOrientation()
+{
+  Hal()->SendUnlockScreenOrientation();
+}
+
+bool
+GetScreenEnabled()
+{
+  bool enabled = false;
+  Hal()->SendGetScreenEnabled(&enabled);
+  return enabled;
+}
+
+void
+SetScreenEnabled(bool aEnabled)
+{
+  Hal()->SendSetScreenEnabled(aEnabled);
+}
+
+bool
+GetKeyLightEnabled()
+{
+  bool enabled = false;
+  Hal()->SendGetKeyLightEnabled(&enabled);
+  return enabled;
+}
+
+void
+SetKeyLightEnabled(bool aEnabled)
+{
+  Hal()->SendSetKeyLightEnabled(aEnabled);
+}
+
+bool
+GetCpuSleepAllowed()
+{
+  bool allowed = true;
+  Hal()->SendGetCpuSleepAllowed(&allowed);
+  return allowed;
+}
+
+void
+SetCpuSleepAllowed(bool aAllowed)
+{
+  Hal()->SendSetCpuSleepAllowed(aAllowed);
+}
+
+double
+GetScreenBrightness()
+{
+  double brightness = 0;
+  Hal()->SendGetScreenBrightness(&brightness);
+  return brightness;
+}
+
+void
+SetScreenBrightness(double aBrightness)
+{
+  Hal()->SendSetScreenBrightness(aBrightness);
+}
+
+void
+AdjustSystemClock(int64_t aDeltaMilliseconds)
+{
+  Hal()->SendAdjustSystemClock(aDeltaMilliseconds);
+}
+
+void
+SetTimezone(const nsCString& aTimezoneSpec)
+{
+  Hal()->SendSetTimezone(nsCString(aTimezoneSpec));
+}
+
+nsCString
+GetTimezone()
+{
+  nsCString timezone;
+  Hal()->SendGetTimezone(&timezone);
+  return timezone;
+}
+
+int32_t
+GetTimezoneOffset()
+{
+  int32_t timezoneOffset;
+  Hal()->SendGetTimezoneOffset(&timezoneOffset);
+  return timezoneOffset;
+}
+
+void
+EnableSystemClockChangeNotifications()
+{
+  Hal()->SendEnableSystemClockChangeNotifications();
+}
+
+void
+DisableSystemClockChangeNotifications()
+{
+  Hal()->SendDisableSystemClockChangeNotifications();
+}
+
+void
+EnableSystemTimezoneChangeNotifications()
+{
+  Hal()->SendEnableSystemTimezoneChangeNotifications();
+}
+
+void
+DisableSystemTimezoneChangeNotifications()
+{
+  Hal()->SendDisableSystemTimezoneChangeNotifications();
+}
+
+void
+Reboot()
+{
+  NS_RUNTIMEABORT("Reboot() can't be called from sandboxed contexts.");
+}
+
+void
+PowerOff()
+{
+  NS_RUNTIMEABORT("PowerOff() can't be called from sandboxed contexts.");
+}
+
+void
+StartForceQuitWatchdog(ShutdownMode aMode, int32_t aTimeoutSecs)
+{
+  NS_RUNTIMEABORT("StartForceQuitWatchdog() can't be called from sandboxed contexts.");
+}
+
+void
+EnableSensorNotifications(SensorType aSensor) {
+  Hal()->SendEnableSensorNotifications(aSensor);
+}
+
+void
+DisableSensorNotifications(SensorType aSensor) {
+  Hal()->SendDisableSensorNotifications(aSensor);
+}
+
+void
+EnableWakeLockNotifications()
+{
+  Hal()->SendEnableWakeLockNotifications();
+}
+
+void
+DisableWakeLockNotifications()
+{
+  Hal()->SendDisableWakeLockNotifications();
+}
+
+void
+ModifyWakeLock(const nsAString &aTopic,
+               WakeLockControl aLockAdjust,
+               WakeLockControl aHiddenAdjust,
+               uint64_t aProcessID)
+{
+  MOZ_ASSERT(aProcessID != CONTENT_PROCESS_ID_UNKNOWN);
+  Hal()->SendModifyWakeLock(nsString(aTopic), aLockAdjust, aHiddenAdjust, aProcessID);
+}
+
+void
+GetWakeLockInfo(const nsAString &aTopic, WakeLockInformation *aWakeLockInfo)
+{
+  Hal()->SendGetWakeLockInfo(nsString(aTopic), aWakeLockInfo);
+}
+
+void
+EnableSwitchNotifications(SwitchDevice aDevice)
+{
+  Hal()->SendEnableSwitchNotifications(aDevice);
+}
+
+void
+DisableSwitchNotifications(SwitchDevice aDevice)
+{
+  Hal()->SendDisableSwitchNotifications(aDevice);
+}
+
+SwitchState
+GetCurrentSwitchState(SwitchDevice aDevice)
+{
+  SwitchState state;
+  Hal()->SendGetCurrentSwitchState(aDevice, &state);
+  return state;
+}
+
+void
+NotifySwitchStateFromInputDevice(SwitchDevice aDevice, SwitchState aState)
+{
+  Unused << aDevice;
+  Unused << aState;
+  NS_RUNTIMEABORT("Only the main process may notify switch state change.");
+}
+
+bool
+EnableAlarm()
+{
+  NS_RUNTIMEABORT("Alarms can't be programmed from sandboxed contexts.  Yet.");
+  return false;
+}
+
+void
+DisableAlarm()
+{
+  NS_RUNTIMEABORT("Alarms can't be programmed from sandboxed contexts.  Yet.");
+}
+
+bool
+SetAlarm(int32_t aSeconds, int32_t aNanoseconds)
+{
+  NS_RUNTIMEABORT("Alarms can't be programmed from sandboxed contexts.  Yet.");
+  return false;
+}
+
+void
+SetProcessPriority(int aPid, ProcessPriority aPriority, uint32_t aLRU)
+{
+  NS_RUNTIMEABORT("Only the main process may set processes' priorities.");
+}
+
+void
+SetCurrentThreadPriority(ThreadPriority aThreadPriority)
+{
+  NS_RUNTIMEABORT("Setting current thread priority cannot be called from sandboxed contexts.");
+}
+
+void
+SetThreadPriority(PlatformThreadId aThreadId,
+                  ThreadPriority aThreadPriority)
+{
+  NS_RUNTIMEABORT("Setting thread priority cannot be called from sandboxed contexts.");
+}
+
+void
+FactoryReset(FactoryResetReason& aReason)
+{
+  if (aReason == FactoryResetReason::Normal) {
+    Hal()->SendFactoryReset(NS_LITERAL_STRING("normal"));
+  } else if (aReason == FactoryResetReason::Wipe) {
+    Hal()->SendFactoryReset(NS_LITERAL_STRING("wipe"));
+  } else if (aReason == FactoryResetReason::Root) {
+    Hal()->SendFactoryReset(NS_LITERAL_STRING("root"));
+  }
+}
+
+void
+StartDiskSpaceWatcher()
+{
+  NS_RUNTIMEABORT("StartDiskSpaceWatcher() can't be called from sandboxed contexts.");
+}
+
+void
+StopDiskSpaceWatcher()
+{
+  NS_RUNTIMEABORT("StopDiskSpaceWatcher() can't be called from sandboxed contexts.");
+}
+
+bool IsHeadphoneEventFromInputDev()
+{
+  NS_RUNTIMEABORT("IsHeadphoneEventFromInputDev() cannot be called from sandboxed contexts.");
+  return false;
+}
+
+nsresult StartSystemService(const char* aSvcName, const char* aArgs)
+{
+  NS_RUNTIMEABORT("System services cannot be controlled from sandboxed contexts.");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+void StopSystemService(const char* aSvcName)
+{
+  NS_RUNTIMEABORT("System services cannot be controlled from sandboxed contexts.");
+}
+
+bool SystemServiceIsRunning(const char* aSvcName)
+{
+  NS_RUNTIMEABORT("System services cannot be controlled from sandboxed contexts.");
+  return false;
+}
+
+class HalParent : public PHalParent
+                , public BatteryObserver
+                , public NetworkObserver
+                , public ISensorObserver
+                , public WakeLockObserver
+                , public ScreenConfigurationObserver
+                , public SwitchObserver
+                , public SystemClockChangeObserver
+                , public SystemTimezoneChangeObserver
+{
+public:
+  virtual void
+  ActorDestroy(ActorDestroyReason aWhy) override
+  {
+    // NB: you *must* unconditionally unregister your observer here,
+    // if it *may* be registered below.
+    hal::UnregisterBatteryObserver(this);
+    hal::UnregisterNetworkObserver(this);
+    hal::UnregisterScreenConfigurationObserver(this);
+    for (int32_t sensor = SENSOR_UNKNOWN + 1;
+         sensor < NUM_SENSOR_TYPE; ++sensor) {
+      hal::UnregisterSensorObserver(SensorType(sensor), this);
+    }
+    hal::UnregisterWakeLockObserver(this);
+    hal::UnregisterSystemClockChangeObserver(this);
+    hal::UnregisterSystemTimezoneChangeObserver(this);
+    for (int32_t switchDevice = SWITCH_DEVICE_UNKNOWN + 1;
+         switchDevice < NUM_SWITCH_DEVICE; ++switchDevice) {
+      hal::UnregisterSwitchObserver(SwitchDevice(switchDevice), this);
+    }
+  }
+
+  virtual bool
+  RecvVibrate(InfallibleTArray<unsigned int>&& pattern,
+              InfallibleTArray<uint64_t>&& id,
+              PBrowserParent *browserParent) override
+  {
+    // We give all content vibration permission.
+    //    TabParent *tabParent = TabParent::GetFrom(browserParent);
+    /* xxxkhuey wtf
+    nsCOMPtr<nsIDOMWindow> window =
+      do_QueryInterface(tabParent->GetBrowserDOMWindow());
+    */
+    WindowIdentifier newID(id, nullptr);
+    hal::Vibrate(pattern, newID);
+    return true;
+  }
+
+  virtual bool
+  RecvCancelVibrate(InfallibleTArray<uint64_t> &&id,
+                    PBrowserParent *browserParent) override
+  {
+    //TabParent *tabParent = TabParent::GetFrom(browserParent);
+    /* XXXkhuey wtf
+    nsCOMPtr<nsIDOMWindow> window =
+      tabParent->GetBrowserDOMWindow();
+    */
+    WindowIdentifier newID(id, nullptr);
+    hal::CancelVibrate(newID);
+    return true;
+  }
+
+  virtual bool
+  RecvEnableBatteryNotifications() override {
+    // We give all content battery-status permission.
+    hal::RegisterBatteryObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvDisableBatteryNotifications() override {
+    hal::UnregisterBatteryObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvGetCurrentBatteryInformation(BatteryInformation* aBatteryInfo) override {
+    // We give all content battery-status permission.
+    hal::GetCurrentBatteryInformation(aBatteryInfo);
+    return true;
+  }
+
+  void Notify(const BatteryInformation& aBatteryInfo) override {
+    Unused << SendNotifyBatteryChange(aBatteryInfo);
+  }
+
+  virtual bool
+  RecvEnableNetworkNotifications() override {
+    // We give all content access to this network-status information.
+    hal::RegisterNetworkObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvDisableNetworkNotifications() override {
+    hal::UnregisterNetworkObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvGetCurrentNetworkInformation(NetworkInformation* aNetworkInfo) override {
+    hal::GetCurrentNetworkInformation(aNetworkInfo);
+    return true;
+  }
+
+  void Notify(const NetworkInformation& aNetworkInfo) override {
+    Unused << SendNotifyNetworkChange(aNetworkInfo);
+  }
+
+  virtual bool
+  RecvEnableScreenConfigurationNotifications() override {
+    // Screen configuration is used to implement CSS and DOM
+    // properties, so all content already has access to this.
+    hal::RegisterScreenConfigurationObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvDisableScreenConfigurationNotifications() override {
+    hal::UnregisterScreenConfigurationObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvGetCurrentScreenConfiguration(ScreenConfiguration* aScreenConfiguration) override {
+    hal::GetCurrentScreenConfiguration(aScreenConfiguration);
+    return true;
+  }
+
+  virtual bool
+  RecvLockScreenOrientation(const dom::ScreenOrientationInternal& aOrientation, bool* aAllowed) override
+  {
+    // FIXME/bug 777980: unprivileged content may only lock
+    // orientation while fullscreen.  We should check whether the
+    // request comes from an actor in a process that might be
+    // fullscreen.  We don't have that information currently.
+    *aAllowed = hal::LockScreenOrientation(aOrientation);
+    return true;
+  }
+
+  virtual bool
+  RecvUnlockScreenOrientation() override
+  {
+    hal::UnlockScreenOrientation();
+    return true;
+  }
+
+  void Notify(const ScreenConfiguration& aScreenConfiguration) override {
+    Unused << SendNotifyScreenConfigurationChange(aScreenConfiguration);
+  }
+
+  virtual bool
+  RecvGetScreenEnabled(bool* aEnabled) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+    *aEnabled = hal::GetScreenEnabled();
+    return true;
+  }
+
+  virtual bool
+  RecvSetScreenEnabled(const bool& aEnabled) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+    hal::SetScreenEnabled(aEnabled);
+    return true;
+  }
+
+  virtual bool
+  RecvGetKeyLightEnabled(bool* aEnabled) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+    *aEnabled = hal::GetKeyLightEnabled();
+    return true;
+  }
+
+  virtual bool
+  RecvSetKeyLightEnabled(const bool& aEnabled) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+    hal::SetKeyLightEnabled(aEnabled);
+    return true;
+  }
+
+  virtual bool
+  RecvGetCpuSleepAllowed(bool* aAllowed) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+    *aAllowed = hal::GetCpuSleepAllowed();
+    return true;
+  }
+
+  virtual bool
+  RecvSetCpuSleepAllowed(const bool& aAllowed) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+    hal::SetCpuSleepAllowed(aAllowed);
+    return true;
+  }
+
+  virtual bool
+  RecvGetScreenBrightness(double* aBrightness) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+    *aBrightness = hal::GetScreenBrightness();
+    return true;
+  }
+
+  virtual bool
+  RecvSetScreenBrightness(const double& aBrightness) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+    hal::SetScreenBrightness(aBrightness);
+    return true;
+  }
+
+  virtual bool
+  RecvAdjustSystemClock(const int64_t &aDeltaMilliseconds) override
+  {
+    if (!AssertAppProcessPermission(this, "time")) {
+      return false;
+    }
+    hal::AdjustSystemClock(aDeltaMilliseconds);
+    return true;
+  }
+
+  virtual bool
+  RecvSetTimezone(const nsCString& aTimezoneSpec) override
+  {
+    if (!AssertAppProcessPermission(this, "time")) {
+      return false;
+    }
+    hal::SetTimezone(aTimezoneSpec);
+    return true;
+  }
+
+  virtual bool
+  RecvGetTimezone(nsCString *aTimezoneSpec) override
+  {
+    if (!AssertAppProcessPermission(this, "time")) {
+      return false;
+    }
+    *aTimezoneSpec = hal::GetTimezone();
+    return true;
+  }
+
+  virtual bool
+  RecvGetTimezoneOffset(int32_t *aTimezoneOffset) override
+  {
+    if (!AssertAppProcessPermission(this, "time")) {
+      return false;
+    }
+    *aTimezoneOffset = hal::GetTimezoneOffset();
+    return true;
+  }
+
+  virtual bool
+  RecvEnableSystemClockChangeNotifications() override
+  {
+    hal::RegisterSystemClockChangeObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvDisableSystemClockChangeNotifications() override
+  {
+    hal::UnregisterSystemClockChangeObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvEnableSystemTimezoneChangeNotifications() override
+  {
+    hal::RegisterSystemTimezoneChangeObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvDisableSystemTimezoneChangeNotifications() override
+  {
+    hal::UnregisterSystemTimezoneChangeObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvEnableSensorNotifications(const SensorType &aSensor) override {
+    // We currently allow any content to register device-sensor
+    // listeners.
+    hal::RegisterSensorObserver(aSensor, this);
+    return true;
+  }
+
+  virtual bool
+  RecvDisableSensorNotifications(const SensorType &aSensor) override {
+    hal::UnregisterSensorObserver(aSensor, this);
+    return true;
+  }
+
+  void Notify(const SensorData& aSensorData) override {
+    Unused << SendNotifySensorChange(aSensorData);
+  }
+
+  virtual bool
+  RecvModifyWakeLock(const nsString& aTopic,
+                     const WakeLockControl& aLockAdjust,
+                     const WakeLockControl& aHiddenAdjust,
+                     const uint64_t& aProcessID) override
+  {
+    MOZ_ASSERT(aProcessID != CONTENT_PROCESS_ID_UNKNOWN);
+
+    // We allow arbitrary content to use wake locks.
+    hal::ModifyWakeLock(aTopic, aLockAdjust, aHiddenAdjust, aProcessID);
+    return true;
+  }
+
+  virtual bool
+  RecvEnableWakeLockNotifications() override
+  {
+    // We allow arbitrary content to use wake locks.
+    hal::RegisterWakeLockObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvDisableWakeLockNotifications() override
+  {
+    hal::UnregisterWakeLockObserver(this);
+    return true;
+  }
+
+  virtual bool
+  RecvGetWakeLockInfo(const nsString &aTopic, WakeLockInformation *aWakeLockInfo) override
+  {
+    hal::GetWakeLockInfo(aTopic, aWakeLockInfo);
+    return true;
+  }
+
+  void Notify(const WakeLockInformation& aWakeLockInfo) override
+  {
+    Unused << SendNotifyWakeLockChange(aWakeLockInfo);
+  }
+
+  virtual bool
+  RecvEnableSwitchNotifications(const SwitchDevice& aDevice) override
+  {
+    // Content has no reason to listen to switch events currently.
+    hal::RegisterSwitchObserver(aDevice, this);
+    return true;
+  }
+
+  virtual bool
+  RecvDisableSwitchNotifications(const SwitchDevice& aDevice) override
+  {
+    hal::UnregisterSwitchObserver(aDevice, this);
+    return true;
+  }
+
+  void Notify(const SwitchEvent& aSwitchEvent) override
+  {
+    Unused << SendNotifySwitchChange(aSwitchEvent);
+  }
+
+  virtual bool
+  RecvGetCurrentSwitchState(const SwitchDevice& aDevice, hal::SwitchState *aState) override
+  {
+    // Content has no reason to listen to switch events currently.
+    *aState = hal::GetCurrentSwitchState(aDevice);
+    return true;
+  }
+
+  void Notify(const int64_t& aClockDeltaMS) override
+  {
+    Unused << SendNotifySystemClockChange(aClockDeltaMS);
+  }
+
+  void Notify(const SystemTimezoneChangeInformation& aSystemTimezoneChangeInfo) override
+  {
+    Unused << SendNotifySystemTimezoneChange(aSystemTimezoneChangeInfo);
+  }
+
+  virtual bool
+  RecvFactoryReset(const nsString& aReason) override
+  {
+    if (!AssertAppProcessPermission(this, "power")) {
+      return false;
+    }
+
+    FactoryResetReason reason = FactoryResetReason::Normal;
+    if (aReason.EqualsLiteral("normal")) {
+      reason = FactoryResetReason::Normal;
+    } else if (aReason.EqualsLiteral("wipe")) {
+      reason = FactoryResetReason::Wipe;
+    } else if (aReason.EqualsLiteral("root")) {
+      reason = FactoryResetReason::Root;
+    } else {
+      // Invalid factory reset reason. That should never happen.
+      return false;
+    }
+
+    hal::FactoryReset(reason);
+    return true;
+  }
+};
+
+class HalChild : public PHalChild {
+public:
+  virtual void
+  ActorDestroy(ActorDestroyReason aWhy) override
+  {
+    sHalChildDestroyed = true;
+  }
+
+  virtual bool
+  RecvNotifyBatteryChange(const BatteryInformation& aBatteryInfo) override {
+    hal::NotifyBatteryChange(aBatteryInfo);
+    return true;
+  }
+
+  virtual bool
+  RecvNotifySensorChange(const hal::SensorData &aSensorData) override;
+
+  virtual bool
+  RecvNotifyNetworkChange(const NetworkInformation& aNetworkInfo) override {
+    hal::NotifyNetworkChange(aNetworkInfo);
+    return true;
+  }
+
+  virtual bool
+  RecvNotifyWakeLockChange(const WakeLockInformation& aWakeLockInfo) override {
+    hal::NotifyWakeLockChange(aWakeLockInfo);
+    return true;
+  }
+
+  virtual bool
+  RecvNotifyScreenConfigurationChange(const ScreenConfiguration& aScreenConfiguration) override {
+    hal::NotifyScreenConfigurationChange(aScreenConfiguration);
+    return true;
+  }
+
+  virtual bool
+  RecvNotifySwitchChange(const mozilla::hal::SwitchEvent& aEvent) override {
+    hal::NotifySwitchChange(aEvent);
+    return true;
+  }
+
+  virtual bool
+  RecvNotifySystemClockChange(const int64_t& aClockDeltaMS) override {
+    hal::NotifySystemClockChange(aClockDeltaMS);
+    return true;
+  }
+
+  virtual bool
+  RecvNotifySystemTimezoneChange(
+    const SystemTimezoneChangeInformation& aSystemTimezoneChangeInfo) override {
+    hal::NotifySystemTimezoneChange(aSystemTimezoneChangeInfo);
+    return true;
+  }
+};
+
+bool
+HalChild::RecvNotifySensorChange(const hal::SensorData &aSensorData) {
+  hal::NotifySensorChange(aSensorData);
+
+  return true;
+}
+
+PHalChild* CreateHalChild() {
+  return new HalChild();
+}
+
+PHalParent* CreateHalParent() {
+  return new HalParent();
+}
+
+} // namespace hal_sandbox
+} // namespace mozilla

hal/sandbox/SandboxHal.h

@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* 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/. */
+
+#ifndef mozilla_SandboxHal_h
+#define mozilla_SandboxHal_h
+
+namespace mozilla {
+namespace hal_sandbox {
+
+class PHalChild;
+class PHalParent;
+
+PHalChild* CreateHalChild();
+
+PHalParent* CreateHalParent();
+
+} // namespace hal_sandbox
+} // namespace mozilla
+
+#endif  // mozilla_SandboxHal_h