summaryrefslogtreecommitdiffstats
path: root/hal/sandbox
diff options
context:
space:
mode:
Diffstat (limited to 'hal/sandbox')
-rw-r--r--hal/sandbox/PHal.ipdl159
-rw-r--r--hal/sandbox/SandboxHal.cpp907
-rw-r--r--hal/sandbox/SandboxHal.h23
3 files changed, 1089 insertions, 0 deletions
diff --git a/hal/sandbox/PHal.ipdl b/hal/sandbox/PHal.ipdl
new file mode 100644
index 000000000..37b69f93f
--- /dev/null
+++ b/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
diff --git a/hal/sandbox/SandboxHal.cpp b/hal/sandbox/SandboxHal.cpp
new file mode 100644
index 000000000..d33a53a2f
--- /dev/null
+++ b/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
diff --git a/hal/sandbox/SandboxHal.h b/hal/sandbox/SandboxHal.h
new file mode 100644
index 000000000..0da2d41fb
--- /dev/null
+++ b/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
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-26 20:17:39 +0000