hal/Hal.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 "HalImpl.h"
   9 #include "HalSandbox.h"
  10 #include "mozilla/Util.h"
  11 #include "nsThreadUtils.h"
  12 #include "nsXULAppAPI.h"
  13 #include "mozilla/Observer.h"
  14 #include "nsIDOMDocument.h"
  15 #include "nsIDOMWindow.h"
  16 #include "mozilla/Services.h"
  17 #include "nsIWebNavigation.h"
  18 #include "nsITabChild.h"
  19 #include "nsIDocShell.h"
  20 #include "mozilla/StaticPtr.h"
  21 #include "mozilla/ClearOnShutdown.h"
  22 #include "WindowIdentifier.h"
  23 #include "mozilla/dom/ScreenOrientation.h"
  24
  25 #ifdef XP_WIN
  26 #include <process.h>
  27 #define getpid _getpid
  28 #endif
  29
  30 using namespace mozilla::services;
  31
  32 #define PROXY_IF_SANDBOXED(_call)                 \
  33   do {                                            \
  34     if (InSandbox()) {                            \
  35       hal_sandbox::_call;                         \
  36     } else {                                      \
  37       hal_impl::_call;                            \
  38     }                                             \
  39   } while (0)
  40
  41 #define RETURN_PROXY_IF_SANDBOXED(_call)          \
  42   do {                                            \
  43     if (InSandbox()) {                            \
  44       return hal_sandbox::_call;                  \
  45     } else {                                      \
  46       return hal_impl::_call;                     \
  47     }                                             \
  48   } while (0)
  49
  50 namespace mozilla {
  51 namespace hal {
  52
  53 PRLogModuleInfo *sHalLog = PR_LOG_DEFINE("hal");
  54
  55 namespace {
  56
  57 void
  58 AssertMainThread()
  59 {
  60   MOZ_ASSERT(NS_IsMainThread());
  61 }
  62
  63 bool
  64 InSandbox()
  65 {
  66   return GeckoProcessType_Content == XRE_GetProcessType();
  67 }
  68
  69 bool
  70 WindowIsActive(nsIDOMWindow *window)
  71 {
  72   NS_ENSURE_TRUE(window, false);
  73
  74   nsCOMPtr<nsIDOMDocument> doc;
  75   window->GetDocument(getter_AddRefs(doc));
  76   NS_ENSURE_TRUE(doc, false);
  77
  78   bool hidden = true;
  79   doc->GetMozHidden(&hidden);
  80   return !hidden;
  81 }
  82
  83 StaticAutoPtr<WindowIdentifier::IDArrayType> gLastIDToVibrate;
  84
  85 void InitLastIDToVibrate()
  86 {
  87   gLastIDToVibrate = new WindowIdentifier::IDArrayType();
  88   ClearOnShutdown(&gLastIDToVibrate);
  89 }
  90
  91 } // anonymous namespace
  92
  93 void
  94 Vibrate(const nsTArray<uint32_t>& pattern, nsIDOMWindow* window)
  95 {
  96   Vibrate(pattern, WindowIdentifier(window));
  97 }
  98
  99 void
 100 Vibrate(const nsTArray<uint32_t>& pattern, const WindowIdentifier &id)
 101 {
 102   AssertMainThread();
 103
 104   // Only active windows may start vibrations.  If |id| hasn't gone
 105   // through the IPC layer -- that is, if our caller is the outside
 106   // world, not hal_proxy -- check whether the window is active.  If
 107   // |id| has gone through IPC, don't check the window's visibility;
 108   // only the window corresponding to the bottommost process has its
 109   // visibility state set correctly.
 110   if (!id.HasTraveledThroughIPC() && !WindowIsActive(id.GetWindow())) {
 111     HAL_LOG(("Vibrate: Window is inactive, dropping vibrate."));
 112     return;
 113   }
 114
 115   if (InSandbox()) {
 116     hal_sandbox::Vibrate(pattern, id);
 117   }
 118   else {
 119     if (!gLastIDToVibrate)
 120       InitLastIDToVibrate();
 121     *gLastIDToVibrate = id.AsArray();
 122
 123     HAL_LOG(("Vibrate: Forwarding to hal_impl."));
 124
 125     // hal_impl doesn't need |id|. Send it an empty id, which will
 126     // assert if it's used.
 127     hal_impl::Vibrate(pattern, WindowIdentifier());
 128   }
 129 }
 130
 131 void
 132 CancelVibrate(nsIDOMWindow* window)
 133 {
 134   CancelVibrate(WindowIdentifier(window));
 135 }
 136
 137 void
 138 CancelVibrate(const WindowIdentifier &id)
 139 {
 140   AssertMainThread();
 141
 142   // Although only active windows may start vibrations, a window may
 143   // cancel its own vibration even if it's no longer active.
 144   //
 145   // After a window is marked as inactive, it sends a CancelVibrate
 146   // request.  We want this request to cancel a playing vibration
 147   // started by that window, so we certainly don't want to reject the
 148   // cancellation request because the window is now inactive.
 149   //
 150   // But it could be the case that, after this window became inactive,
 151   // some other window came along and started a vibration.  We don't
 152   // want this window's cancellation request to cancel that window's
 153   // actively-playing vibration!
 154   //
 155   // To solve this problem, we keep track of the id of the last window
 156   // to start a vibration, and only accepts cancellation requests from
 157   // the same window.  All other cancellation requests are ignored.
 158
 159   if (InSandbox()) {
 160     hal_sandbox::CancelVibrate(id);
 161   }
 162   else if (gLastIDToVibrate && *gLastIDToVibrate == id.AsArray()) {
 163     // Don't forward our ID to hal_impl. It doesn't need it, and we
 164     // don't want it to be tempted to read it.  The empty identifier
 165     // will assert if it's used.
 166     HAL_LOG(("CancelVibrate: Forwarding to hal_impl."));
 167     hal_impl::CancelVibrate(WindowIdentifier());
 168   }
 169 }
 170
 171 template <class InfoType>
 172 class ObserversManager
 173 {
 174 public:
 175   void AddObserver(Observer<InfoType>* aObserver) {
 176     if (!mObservers) {
 177       mObservers = new mozilla::ObserverList<InfoType>();
 178     }
 179
 180     mObservers->AddObserver(aObserver);
 181
 182     if (mObservers->Length() == 1) {
 183       EnableNotifications();
 184     }
 185   }
 186
 187   void RemoveObserver(Observer<InfoType>* aObserver) {
 188     // If mObservers is null, that means there are no observers.
 189     // In addition, if RemoveObserver() returns false, that means we didn't
 190     // find the observer.
 191     // In both cases, that is a logical error we want to make sure the developer
 192     // notices.
 193
 194     MOZ_ASSERT(mObservers);
 195
 196 #ifndef DEBUG
 197     if (!mObservers) {
 198       return;
 199     }
 200 #endif
 201
 202     DebugOnly<bool> removed = mObservers->RemoveObserver(aObserver);
 203     MOZ_ASSERT(removed);
 204
 205     if (mObservers->Length() == 0) {
 206       DisableNotifications();
 207
 208       OnNotificationsDisabled();
 209
 210       delete mObservers;
 211       mObservers = 0;
 212     }
 213   }
 214
 215   void BroadcastInformation(const InfoType& aInfo) {
 216     // It is possible for mObservers to be NULL here on some platforms,
 217     // because a call to BroadcastInformation gets queued up asynchronously
 218     // while RemoveObserver is running (and before the notifications are
 219     // disabled). The queued call can then get run after mObservers has
 220     // been nulled out. See bug 757025.
 221     if (!mObservers) {
 222       return;
 223     }
 224     mObservers->Broadcast(aInfo);
 225   }
 226
 227 protected:
 228   virtual void EnableNotifications() = 0;
 229   virtual void DisableNotifications() = 0;
 230   virtual void OnNotificationsDisabled() {}
 231
 232 private:
 233   mozilla::ObserverList<InfoType>* mObservers;
 234 };
 235
 236 template <class InfoType>
 237 class CachingObserversManager : public ObserversManager<InfoType>
 238 {
 239 public:
 240   InfoType GetCurrentInformation() {
 241     if (mHasValidCache) {
 242       return mInfo;
 243     }
 244
 245     GetCurrentInformationInternal(&mInfo);
 246     mHasValidCache = true;
 247     return mInfo;
 248   }
 249
 250   void CacheInformation(const InfoType& aInfo) {
 251     mHasValidCache = true;
 252     mInfo = aInfo;
 253   }
 254
 255   void BroadcastCachedInformation() {
 256     this->BroadcastInformation(mInfo);
 257   }
 258
 259 protected:
 260   virtual void GetCurrentInformationInternal(InfoType*) = 0;
 261
 262   virtual void OnNotificationsDisabled() {
 263     mHasValidCache = false;
 264   }
 265
 266 private:
 267   InfoType                mInfo;
 268   bool                    mHasValidCache;
 269 };
 270
 271 class BatteryObserversManager : public CachingObserversManager<BatteryInformation>
 272 {
 273 protected:
 274   void EnableNotifications() {
 275     PROXY_IF_SANDBOXED(EnableBatteryNotifications());
 276   }
 277
 278   void DisableNotifications() {
 279     PROXY_IF_SANDBOXED(DisableBatteryNotifications());
 280   }
 281
 282   void GetCurrentInformationInternal(BatteryInformation* aInfo) {
 283     PROXY_IF_SANDBOXED(GetCurrentBatteryInformation(aInfo));
 284   }
 285 };
 286
 287 static BatteryObserversManager sBatteryObservers;
 288
 289 class NetworkObserversManager : public CachingObserversManager<NetworkInformation>
 290 {
 291 protected:
 292   void EnableNotifications() {
 293     PROXY_IF_SANDBOXED(EnableNetworkNotifications());
 294   }
 295
 296   void DisableNotifications() {
 297     PROXY_IF_SANDBOXED(DisableNetworkNotifications());
 298   }
 299
 300   void GetCurrentInformationInternal(NetworkInformation* aInfo) {
 301     PROXY_IF_SANDBOXED(GetCurrentNetworkInformation(aInfo));
 302   }
 303 };
 304
 305 static NetworkObserversManager sNetworkObservers;
 306
 307 class WakeLockObserversManager : public ObserversManager<WakeLockInformation>
 308 {
 309 protected:
 310   void EnableNotifications() {
 311     PROXY_IF_SANDBOXED(EnableWakeLockNotifications());
 312   }
 313
 314   void DisableNotifications() {
 315     PROXY_IF_SANDBOXED(DisableWakeLockNotifications());
 316   }
 317 };
 318
 319 static WakeLockObserversManager sWakeLockObservers;
 320
 321 class ScreenConfigurationObserversManager : public CachingObserversManager<ScreenConfiguration>
 322 {
 323 protected:
 324   void EnableNotifications() {
 325     PROXY_IF_SANDBOXED(EnableScreenConfigurationNotifications());
 326   }
 327
 328   void DisableNotifications() {
 329     PROXY_IF_SANDBOXED(DisableScreenConfigurationNotifications());
 330   }
 331
 332   void GetCurrentInformationInternal(ScreenConfiguration* aInfo) {
 333     PROXY_IF_SANDBOXED(GetCurrentScreenConfiguration(aInfo));
 334   }
 335 };
 336
 337 static ScreenConfigurationObserversManager sScreenConfigurationObservers;
 338
 339 void
 340 RegisterBatteryObserver(BatteryObserver* aObserver)
 341 {
 342   AssertMainThread();
 343   sBatteryObservers.AddObserver(aObserver);
 344 }
 345
 346 void
 347 UnregisterBatteryObserver(BatteryObserver* aObserver)
 348 {
 349   AssertMainThread();
 350   sBatteryObservers.RemoveObserver(aObserver);
 351 }
 352
 353 void
 354 GetCurrentBatteryInformation(BatteryInformation* aInfo)
 355 {
 356   AssertMainThread();
 357   *aInfo = sBatteryObservers.GetCurrentInformation();
 358 }
 359
 360 void
 361 NotifyBatteryChange(const BatteryInformation& aInfo)
 362 {
 363   AssertMainThread();
 364   sBatteryObservers.CacheInformation(aInfo);
 365   sBatteryObservers.BroadcastCachedInformation();
 366 }
 367
 368 bool GetScreenEnabled()
 369 {
 370   AssertMainThread();
 371   RETURN_PROXY_IF_SANDBOXED(GetScreenEnabled());
 372 }
 373
 374 void SetScreenEnabled(bool enabled)
 375 {
 376   AssertMainThread();
 377   PROXY_IF_SANDBOXED(SetScreenEnabled(enabled));
 378 }
 379
 380 bool GetCpuSleepAllowed()
 381 {
 382   // Generally for interfaces that are accessible by normal web content
 383   // we should cache the result and be notified on state changes, like
 384   // what the battery API does. But since this is only used by
 385   // privileged interface, the synchronous getter is OK here.
 386   AssertMainThread();
 387   RETURN_PROXY_IF_SANDBOXED(GetCpuSleepAllowed());
 388 }
 389
 390 void SetCpuSleepAllowed(bool allowed)
 391 {
 392   AssertMainThread();
 393   PROXY_IF_SANDBOXED(SetCpuSleepAllowed(allowed));
 394 }
 395
 396 double GetScreenBrightness()
 397 {
 398   AssertMainThread();
 399   RETURN_PROXY_IF_SANDBOXED(GetScreenBrightness());
 400 }
 401
 402 void SetScreenBrightness(double brightness)
 403 {
 404   AssertMainThread();
 405   PROXY_IF_SANDBOXED(SetScreenBrightness(clamped(brightness, 0.0, 1.0)));
 406 }
 407
 408 bool SetLight(LightType light, const hal::LightConfiguration& aConfig)
 409 {
 410   AssertMainThread();
 411   RETURN_PROXY_IF_SANDBOXED(SetLight(light, aConfig));
 412 }
 413
 414 bool GetLight(LightType light, hal::LightConfiguration* aConfig)
 415 {
 416   AssertMainThread();
 417   RETURN_PROXY_IF_SANDBOXED(GetLight(light, aConfig));
 418 }
 419
 420
 421 void
 422 AdjustSystemClock(int32_t aDeltaMilliseconds)
 423 {
 424   AssertMainThread();
 425   PROXY_IF_SANDBOXED(AdjustSystemClock(aDeltaMilliseconds));
 426 }
 427
 428 void
 429 SetTimezone(const nsCString& aTimezoneSpec)
 430 {
 431   AssertMainThread();
 432   PROXY_IF_SANDBOXED(SetTimezone(aTimezoneSpec));
 433 }
 434
 435 void
 436 EnableSensorNotifications(SensorType aSensor) {
 437   AssertMainThread();
 438   PROXY_IF_SANDBOXED(EnableSensorNotifications(aSensor));
 439 }
 440
 441 void
 442 DisableSensorNotifications(SensorType aSensor) {
 443   AssertMainThread();
 444   PROXY_IF_SANDBOXED(DisableSensorNotifications(aSensor));
 445 }
 446
 447 typedef mozilla::ObserverList<SensorData> SensorObserverList;
 448 static SensorObserverList* gSensorObservers = NULL;
 449
 450 static SensorObserverList &
 451 GetSensorObservers(SensorType sensor_type) {
 452   MOZ_ASSERT(sensor_type < NUM_SENSOR_TYPE);
 453
 454   if(gSensorObservers == NULL)
 455     gSensorObservers = new SensorObserverList[NUM_SENSOR_TYPE];
 456   return gSensorObservers[sensor_type];
 457 }
 458
 459 void
 460 RegisterSensorObserver(SensorType aSensor, ISensorObserver *aObserver) {
 461   SensorObserverList &observers = GetSensorObservers(aSensor);
 462
 463   AssertMainThread();
 464
 465   observers.AddObserver(aObserver);
 466   if(observers.Length() == 1) {
 467     EnableSensorNotifications(aSensor);
 468   }
 469 }
 470
 471 void
 472 UnregisterSensorObserver(SensorType aSensor, ISensorObserver *aObserver) {
 473   SensorObserverList &observers = GetSensorObservers(aSensor);
 474
 475   AssertMainThread();
 476
 477   observers.RemoveObserver(aObserver);
 478   if (observers.Length() > 0) {
 479     return;
 480   }
 481   DisableSensorNotifications(aSensor);
 482
 483   // Destroy sSensorObservers only if all observer lists are empty.
 484   for (int i = 0; i < NUM_SENSOR_TYPE; i++) {
 485     if (gSensorObservers[i].Length() > 0) {
 486       return;
 487     }
 488   }
 489   delete [] gSensorObservers;
 490   gSensorObservers = nullptr;
 491 }
 492
 493 void
 494 NotifySensorChange(const SensorData &aSensorData) {
 495   SensorObserverList &observers = GetSensorObservers(aSensorData.sensor());
 496
 497   AssertMainThread();
 498
 499   observers.Broadcast(aSensorData);
 500 }
 501
 502 void
 503 RegisterNetworkObserver(NetworkObserver* aObserver)
 504 {
 505   AssertMainThread();
 506   sNetworkObservers.AddObserver(aObserver);
 507 }
 508
 509 void
 510 UnregisterNetworkObserver(NetworkObserver* aObserver)
 511 {
 512   AssertMainThread();
 513   sNetworkObservers.RemoveObserver(aObserver);
 514 }
 515
 516 void
 517 GetCurrentNetworkInformation(NetworkInformation* aInfo)
 518 {
 519   AssertMainThread();
 520   *aInfo = sNetworkObservers.GetCurrentInformation();
 521 }
 522
 523 void
 524 NotifyNetworkChange(const NetworkInformation& aInfo)
 525 {
 526   sNetworkObservers.CacheInformation(aInfo);
 527   sNetworkObservers.BroadcastCachedInformation();
 528 }
 529
 530 void Reboot()
 531 {
 532   AssertMainThread();
 533   PROXY_IF_SANDBOXED(Reboot());
 534 }
 535
 536 void PowerOff()
 537 {
 538   AssertMainThread();
 539   PROXY_IF_SANDBOXED(PowerOff());
 540 }
 541
 542 void
 543 RegisterWakeLockObserver(WakeLockObserver* aObserver)
 544 {
 545   AssertMainThread();
 546   sWakeLockObservers.AddObserver(aObserver);
 547 }
 548
 549 void
 550 UnregisterWakeLockObserver(WakeLockObserver* aObserver)
 551 {
 552   AssertMainThread();
 553   sWakeLockObservers.RemoveObserver(aObserver);
 554 }
 555
 556 void
 557 ModifyWakeLock(const nsAString &aTopic,
 558                hal::WakeLockControl aLockAdjust,
 559                hal::WakeLockControl aHiddenAdjust)
 560 {
 561   AssertMainThread();
 562   PROXY_IF_SANDBOXED(ModifyWakeLock(aTopic, aLockAdjust, aHiddenAdjust));
 563 }
 564
 565 void
 566 GetWakeLockInfo(const nsAString &aTopic, WakeLockInformation *aWakeLockInfo)
 567 {
 568   AssertMainThread();
 569   PROXY_IF_SANDBOXED(GetWakeLockInfo(aTopic, aWakeLockInfo));
 570 }
 571
 572 void
 573 NotifyWakeLockChange(const WakeLockInformation& aInfo)
 574 {
 575   AssertMainThread();
 576   sWakeLockObservers.BroadcastInformation(aInfo);
 577 }
 578
 579 void
 580 RegisterScreenConfigurationObserver(ScreenConfigurationObserver* aObserver)
 581 {
 582   AssertMainThread();
 583   sScreenConfigurationObservers.AddObserver(aObserver);
 584 }
 585
 586 void
 587 UnregisterScreenConfigurationObserver(ScreenConfigurationObserver* aObserver)
 588 {
 589   AssertMainThread();
 590   sScreenConfigurationObservers.RemoveObserver(aObserver);
 591 }
 592
 593 void
 594 GetCurrentScreenConfiguration(ScreenConfiguration* aScreenConfiguration)
 595 {
 596   AssertMainThread();
 597   *aScreenConfiguration = sScreenConfigurationObservers.GetCurrentInformation();
 598 }
 599
 600 void
 601 NotifyScreenConfigurationChange(const ScreenConfiguration& aScreenConfiguration)
 602 {
 603   sScreenConfigurationObservers.CacheInformation(aScreenConfiguration);
 604   sScreenConfigurationObservers.BroadcastCachedInformation();
 605 }
 606
 607 bool
 608 LockScreenOrientation(const dom::ScreenOrientation& aOrientation)
 609 {
 610   AssertMainThread();
 611   RETURN_PROXY_IF_SANDBOXED(LockScreenOrientation(aOrientation));
 612 }
 613
 614 void
 615 UnlockScreenOrientation()
 616 {
 617   AssertMainThread();
 618   PROXY_IF_SANDBOXED(UnlockScreenOrientation());
 619 }
 620
 621 void
 622 EnableSwitchNotifications(hal::SwitchDevice aDevice) {
 623   AssertMainThread();
 624   PROXY_IF_SANDBOXED(EnableSwitchNotifications(aDevice));
 625 }
 626
 627 void
 628 DisableSwitchNotifications(hal::SwitchDevice aDevice) {
 629   AssertMainThread();
 630   PROXY_IF_SANDBOXED(DisableSwitchNotifications(aDevice));
 631 }
 632
 633 hal::SwitchState GetCurrentSwitchState(hal::SwitchDevice aDevice)
 634 {
 635   AssertMainThread();
 636   RETURN_PROXY_IF_SANDBOXED(GetCurrentSwitchState(aDevice));
 637 }
 638
 639 typedef mozilla::ObserverList<SwitchEvent> SwitchObserverList;
 640
 641 static SwitchObserverList *sSwitchObserverLists = NULL;
 642
 643 static SwitchObserverList&
 644 GetSwitchObserverList(hal::SwitchDevice aDevice) {
 645   MOZ_ASSERT(0 <= aDevice && aDevice < NUM_SWITCH_DEVICE);
 646   if (sSwitchObserverLists == NULL) {
 647     sSwitchObserverLists = new SwitchObserverList[NUM_SWITCH_DEVICE];
 648   }
 649   return sSwitchObserverLists[aDevice];
 650 }
 651
 652 static void
 653 ReleaseObserversIfNeeded() {
 654   for (int i = 0; i < NUM_SWITCH_DEVICE; i++) {
 655     if (sSwitchObserverLists[i].Length() != 0)
 656       return;
 657   }
 658
 659   //The length of every list is 0, no observer in the list.
 660   delete [] sSwitchObserverLists;
 661   sSwitchObserverLists = NULL;
 662 }
 663
 664 void
 665 RegisterSwitchObserver(hal::SwitchDevice aDevice, hal::SwitchObserver *aObserver)
 666 {
 667   AssertMainThread();
 668   SwitchObserverList& observer = GetSwitchObserverList(aDevice);
 669   observer.AddObserver(aObserver);
 670   if (observer.Length() == 1) {
 671     EnableSwitchNotifications(aDevice);
 672   }
 673 }
 674
 675 void
 676 UnregisterSwitchObserver(hal::SwitchDevice aDevice, hal::SwitchObserver *aObserver)
 677 {
 678   AssertMainThread();
 679   SwitchObserverList& observer = GetSwitchObserverList(aDevice);
 680   observer.RemoveObserver(aObserver);
 681   if (observer.Length() == 0) {
 682     DisableSwitchNotifications(aDevice);
 683     ReleaseObserversIfNeeded();
 684   }
 685 }
 686
 687 void
 688 NotifySwitchChange(const hal::SwitchEvent& aEvent)
 689 {
 690   // When callback this notification, main thread may call unregister function
 691   // first. We should check if this pointer is valid.
 692   if (!sSwitchObserverLists)
 693     return;
 694
 695   SwitchObserverList& observer = GetSwitchObserverList(aEvent.device());
 696   observer.Broadcast(aEvent);
 697 }
 698
 699 static AlarmObserver* sAlarmObserver;
 700
 701 bool
 702 RegisterTheOneAlarmObserver(AlarmObserver* aObserver)
 703 {
 704   MOZ_ASSERT(!InSandbox());
 705   MOZ_ASSERT(!sAlarmObserver);
 706
 707   sAlarmObserver = aObserver;
 708   RETURN_PROXY_IF_SANDBOXED(EnableAlarm());
 709 }
 710
 711 void
 712 UnregisterTheOneAlarmObserver()
 713 {
 714   if (sAlarmObserver) {
 715     sAlarmObserver = NULL;
 716     PROXY_IF_SANDBOXED(DisableAlarm());
 717   }
 718 }
 719
 720 void
 721 NotifyAlarmFired()
 722 {
 723   if (sAlarmObserver) {
 724     sAlarmObserver->Notify(void_t());
 725   }
 726 }
 727
 728 bool
 729 SetAlarm(int32_t aSeconds, int32_t aNanoseconds)
 730 {
 731   // It's pointless to program an alarm nothing is going to observe ...
 732   MOZ_ASSERT(sAlarmObserver);
 733   RETURN_PROXY_IF_SANDBOXED(SetAlarm(aSeconds, aNanoseconds));
 734 }
 735
 736 void
 737 SetProcessPriority(int aPid, ProcessPriority aPriority)
 738 {
 739   if (InSandbox()) {
 740     hal_sandbox::SetProcessPriority(aPid, aPriority);
 741   }
 742   else {
 743     hal_impl::SetProcessPriority(aPid, aPriority);
 744   }
 745 }
 746
 747 } // namespace hal
 748 } // namespace mozilla